typing is now correct for the file system

src/rt/rfwfs/collection.ts

@@ -1,58 +0,0 @@
-import { type Entry } from "./main"
-
-import entry_search from "./index"
-
-type Files<T extends Entry<T>> = Entry<T>[]
-
-interface EntryCollectionManipulate<T extends Entry<T>> {
-	pop: (file_name: string) => Entry<T> | undefined,
-	get: (file_name: string) => Entry<T> | undefined
-	push: (entry: Entry<T>) => boolean,
-	sort: () => void,
-}
-interface EntryCollection<T extends Entry<T>> extends EntryCollectionManipulate<T> {
-	readonly inner: Files<T>
-}
-
-function sort<E extends Entry<E>>(self: EntryCollection<E>) {
-	self.inner.sort((a,z) => a.name.localeCompare(z.name))
-}
-
-function push<E extends Entry<E>>(self: EntryCollection<E>, entry: Entry<E>) {
-	const no_duplicates = entry_search(self.inner, entry.name)
-	if (!no_duplicates) {
-		self.push(entry)
-		self.sort()
-		return true
-	}
-	return false
-}
-
-function get<E extends Entry<E>>(self: EntryCollection<E>, file_name: string) {
-	const file_search = entry_search(self.inner, file_name)
-	return file_search ? file_search.result : undefined
-}
-
-function pop<E extends Entry<E>>(self: EntryCollection<E>, file_name: string) {
-	const file_search = entry_search(self.inner, file_name)
-	if (file_search) {
-		self.inner.splice(file_search.index, 1)
-		return file_search.result
-	}
-	return undefined
-}
-
-function entry_collection<E extends Entry<E>>(inner: Files<E>): EntryCollection<E> {
-	const collection = { inner: inner } as EntryCollection<E>
-	collection.sort = function()          { return sort(this) }
-	collection.push = function(entry)     { return push(this, entry) }
-	collection.get  = function(file_name) { return get(this, file_name) }
-	collection.pop  = function(file_name) { return pop(this, file_name) }
-	return collection
-}
-
-export {
-	entry_collection,
-	type EntryCollection,
-	type Files,
-}

src/rt/rfwfs/index.ts

@@ -1,5 +1,4 @@
 import { type Entry } from "./main"
-import { type Files } from "./collection"
 
 interface Wrap<T> {
 	readonly result: T,
@@ -9,14 +8,14 @@ function wrap_result<T>(result: T, index: number): Wrap<T> {
 	return { result: result, index: index }
 }
 
-export default function entry_search<T extends Entry<T>>(cloned_file_collection: Files<T>, file_name: string): Wrap<Entry<T>> | undefined {
+export default function entry_search<T extends Entry>(cloned_file_collection: T[], file_name: string): Wrap<T> | undefined {
 	let start = 0
 	let end = cloned_file_collection.length-1
 	while (start<=end) {
 		const median = (start+end)>>1
 		const median_name = cloned_file_collection[median].name
 
-		if (median_name == file_name) { //left == right && (T == U) is not necessary
+		if (median_name === file_name) {
 			return wrap_result(cloned_file_collection[median], median)
 		} else if (median_name<file_name) {
 			start = median+1

src/rt/rfwfs/main.ts

@@ -1,4 +1,4 @@
-import { type EntryCollection } from "./collection"
+import entry_search from "./index"
 
 const enum EntryType {
 	Directory,
@@ -11,34 +11,90 @@ const enum Permissions {
 	none
 }
 
-interface Entry<T extends Entry<T>> {
+interface Entry {
 	readonly name: string,
 	readonly type: EntryType,
-	readonly inner: T,
 	readonly timestamp: number,
-	readonly collection?: EntryCollection<T>,
 	readonly permissions: Permissions,
 }
+interface EntryCollectionInner<T extends Entry> extends Entry {
+	readonly collection: T[],
+}
+interface EntryFile<T> extends Entry {
+	inner: T
+}
+
+interface EntryCollection<T extends Entry> extends EntryCollectionInner<T> {
+	pop: (file_name: string) => T | undefined,
+	get: (file_name: string) => T | undefined
+	push: <E extends Entry>(entry: E) => boolean,
+	sort: () => void,
+}
 interface Rfwfs {
-	new_entry: <T extends Entry<T>>(name: string, permissions: Permissions, timestamp: number, inner: T) => Entry<T>,
-	entry_trait: <T extends Entry<T>>(inner: T) => EntryCollection<T>
-	new_entry_tree: <T>(files: T) => T,
+	is_dir: <T extends Entry>(entry: T) => boolean,
+	is_file: <T extends Entry>(entry: T) => boolean,
+	new_entry: <T>(name: string, permissions: Permissions, timestamp: number, inner: T) => EntryFile<T>,
+	new_collection: <T extends Entry>(inner: T[]) => EntryCollection<T>,
+}
+
+function sort<E extends Entry>(self: EntryCollection<E>) {
+	self.collection.sort((a,z) => a.name.localeCompare(z.name))
+}
+
+function push<E extends Entry>(self: EntryCollection<E>, entry: Entry) {
+	const no_duplicates = entry_search(self.collection, entry.name)
+	if (!no_duplicates) {
+		self.push(entry)
+		self.sort()
+		return true
+	}
+	return false
+}
+
+function get<E extends Entry>(self: EntryCollection<E>, file_name: string) {
+	const file_search = entry_search(self.collection, file_name)
+	return file_search ? file_search.result : undefined
+}
+
+function pop<E extends Entry>(self: EntryCollection<E>, file_name: string) {
+	const file_search = entry_search(self.collection, file_name)
+	if (file_search) {
+		self.collection.splice(file_search.index, 1)
+		return file_search.result
+	}
+	return undefined
 }
 
 const rfwfs = {} as Rfwfs
 
+rfwfs.is_dir = function(entry) {
+	return entry.type === EntryType.Directory
+}
+
+rfwfs.is_file = function(entry) {
+	return entry.type === EntryType.File
+}
+
 rfwfs.new_entry = function(name, permissions, timestamp, inner) {
-	const file_type = typeof inner == "object" ? EntryType.Directory : EntryType.File
 	return {
 		name: name,
-		type: file_type,
+		type: typeof inner === "object" ? EntryType.Directory : EntryType.File,
 		inner: inner,
-		timestamp: timestamp ? timestamp : Math.floor(Date.now()/1000),
-		collection: file_type === EntryType.Directory ? this.entry_trait(inner) : undefined,
+		timestamp: timestamp ? timestamp : (Date.now()/1000)|0,
 		permissions: permissions,
 	}
 }
 
+rfwfs.new_collection = function<T extends Entry>(collection: T[]): EntryCollection<T> {
+	const collection_trait = { collection: collection } as EntryCollection<T>
+	collection_trait.sort = function()          { return sort(this) }
+	collection_trait.push = function(entry)     { return push(this, entry) }
+	collection_trait.get  = function(file_name) { return get(this, file_name) }
+	collection_trait.pop  = function(file_name) { return pop(this, file_name) }
+	return collection_trait
+}
+
+export default rfwfs
 export {
 	EntryType,
 	Permissions,

src/rt/rfwfs/tree.ts

@@ -0,0 +1,11 @@
+import rfwfs, { Permissions } from "./main";
+
+const time_now = (Date.now()/1000)|0
+
+const fs = rfwfs.new_collection([
+	rfwfs.new_entry("/", Permissions.r, time_now, rfwfs.new_collection([
+		rfwfs.new_entry("home", Permissions.r, time_now, "hi")
+	]))
+])
+
+export default fs