@wtasnorg/node-lib 0.0.5 → 0.0.6

package/DEV_CHECKLIST.md

@@ -8,7 +8,6 @@
 - [ ] Have you used the code locally?
 - [ ] Check your email and username. Protect PII. `git log -n1`
 
-
 ```bash
 npm run build
 npm run test

package/docs/functions/createFindDirectories.md

@@ -0,0 +1,38 @@
+[**@wtasnorg/node-lib**](../README.md)
+
+***
+
+[@wtasnorg/node-lib](../globals.md) / createFindDirectories
+
+# Function: createFindDirectories()
+
+> **createFindDirectories**(`deps`): (`root`, `options`) => `Promise`\<`string`[]\>
+
+Defined in: [find.ts:19](https://github.com/wtasg/node-lib/blob/01d2e57d5a7dbc3451098355b40ab686f5320efe/src/find.ts#L19)
+
+Factory that produces an async findDirectories function with
+injected filesystem dependencies for full testability.
+
+## Parameters
+
+### deps
+
+[`FileSystemDependencies`](../interfaces/FileSystemDependencies.md)
+
+## Returns
+
+> (`root`, `options`): `Promise`\<`string`[]\>
+
+### Parameters
+
+#### root
+
+`string`
+
+#### options
+
+[`FindDirectoriesOptions`](../interfaces/FindDirectoriesOptions.md) = `{}`
+
+### Returns
+
+`Promise`\<`string`[]\>

package/docs/functions/hello.md

@@ -8,7 +8,7 @@
 
 > **hello**(): `Promise`\<`string`\>
 
-Defined in: [hello.ts:6](https://github.com/wtasg/node-lib/blob/890fd5e866d9096470d56594a5788bf55e34bf7c/src/hello.ts#L6)
+Defined in: [hello.ts:6](https://github.com/wtasg/node-lib/blob/01d2e57d5a7dbc3451098355b40ab686f5320efe/src/hello.ts#L6)
 
 A sample function that should work to test if lib is installed correctly.
 

package/docs/functions/pojo.md

@@ -8,7 +8,7 @@
 
 > **pojo**\<`T`\>(`instance`): `Record`\<`string`, `any`\>
 
-Defined in: [pojo.ts:10](https://github.com/wtasg/node-lib/blob/890fd5e866d9096470d56594a5788bf55e34bf7c/src/pojo.ts#L10)
+Defined in: [pojo.ts:10](https://github.com/wtasg/node-lib/blob/01d2e57d5a7dbc3451098355b40ab686f5320efe/src/pojo.ts#L10)
 
 Convert a class instance into a plain JavaScript object.
 Copies only the instance's own enumerable data properties

package/docs/globals.md

@@ -4,7 +4,13 @@
 
 # @wtasnorg/node-lib
 
+## Interfaces
+
+- [FileSystemDependencies](interfaces/FileSystemDependencies.md)
+- [FindDirectoriesOptions](interfaces/FindDirectoriesOptions.md)
+
 ## Functions
 
+- [createFindDirectories](functions/createFindDirectories.md)
 - [hello](functions/hello.md)
 - [pojo](functions/pojo.md)

package/docs/interfaces/FileSystemDependencies.md

@@ -0,0 +1,51 @@
+[**@wtasnorg/node-lib**](../README.md)
+
+***
+
+[@wtasnorg/node-lib](../globals.md) / FileSystemDependencies
+
+# Interface: FileSystemDependencies
+
+Defined in: [find.ts:3](https://github.com/wtasg/node-lib/blob/01d2e57d5a7dbc3451098355b40ab686f5320efe/src/find.ts#L3)
+
+## Properties
+
+### readdir()
+
+> **readdir**: (`path`, `opts`) => `Promise`\<`object`[]\>
+
+Defined in: [find.ts:4](https://github.com/wtasg/node-lib/blob/01d2e57d5a7dbc3451098355b40ab686f5320efe/src/find.ts#L4)
+
+#### Parameters
+
+##### path
+
+`string`
+
+##### opts
+
+###### withFileTypes
+
+`true`
+
+#### Returns
+
+`Promise`\<`object`[]\>
+
+***
+
+### stat()
+
+> **stat**: (`path`) => `Promise`\<\{ `isDirectory`: `boolean`; \}\>
+
+Defined in: [find.ts:5](https://github.com/wtasg/node-lib/blob/01d2e57d5a7dbc3451098355b40ab686f5320efe/src/find.ts#L5)
+
+#### Parameters
+
+##### path
+
+`string`
+
+#### Returns
+
+`Promise`\<\{ `isDirectory`: `boolean`; \}\>

package/docs/interfaces/FindDirectoriesOptions.md

@@ -0,0 +1,41 @@
+[**@wtasnorg/node-lib**](../README.md)
+
+***
+
+[@wtasnorg/node-lib](../globals.md) / FindDirectoriesOptions
+
+# Interface: FindDirectoriesOptions
+
+Defined in: [find.ts:8](https://github.com/wtasg/node-lib/blob/01d2e57d5a7dbc3451098355b40ab686f5320efe/src/find.ts#L8)
+
+## Properties
+
+### allowlist?
+
+> `optional` **allowlist**: `string`[] \| (`absPath`, `name`) => `boolean`
+
+Defined in: [find.ts:11](https://github.com/wtasg/node-lib/blob/01d2e57d5a7dbc3451098355b40ab686f5320efe/src/find.ts#L11)
+
+***
+
+### blocklist?
+
+> `optional` **blocklist**: `string`[] \| (`absPath`, `name`) => `boolean`
+
+Defined in: [find.ts:12](https://github.com/wtasg/node-lib/blob/01d2e57d5a7dbc3451098355b40ab686f5320efe/src/find.ts#L12)
+
+***
+
+### followSymlinks?
+
+> `optional` **followSymlinks**: `boolean`
+
+Defined in: [find.ts:10](https://github.com/wtasg/node-lib/blob/01d2e57d5a7dbc3451098355b40ab686f5320efe/src/find.ts#L10)
+
+***
+
+### maxDepth?
+
+> `optional` **maxDepth**: `number`
+
+Defined in: [find.ts:9](https://github.com/wtasg/node-lib/blob/01d2e57d5a7dbc3451098355b40ab686f5320efe/src/find.ts#L9)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wtasnorg/node-lib",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "node library",
   "main": "src/index.js",
   "scripts": {
@@ -28,7 +28,7 @@
   },
   "devDependencies": {
     "@types/node": "^24.10.1",
-    "typedoc": "^0.28.14",
+    "typedoc": "^0.28.15",
     "typedoc-plugin-markdown": "^4.9.0",
     "typescript": "^5.9.3"
   }

package/src/find.d.ts

@@ -0,0 +1,25 @@
+interface FileSystemDependencies {
+    readdir: (path: string, opts: {
+        withFileTypes: true;
+    }) => Promise<{
+        name: string;
+        isDirectory(): boolean;
+    }[]>;
+    stat: (path: string) => Promise<{
+        isDirectory(): boolean;
+    }>;
+}
+interface FindDirectoriesOptions {
+    maxDepth?: number;
+    followSymlinks?: boolean;
+    allowlist?: string[] | ((absPath: string, name: string) => boolean);
+    blocklist?: string[] | ((absPath: string, name: string) => boolean);
+}
+/**
+ * Factory that produces an async findDirectories function with
+ * injected filesystem dependencies for full testability.
+ */
+declare function createFindDirectories(deps: FileSystemDependencies): (root: string, options?: FindDirectoriesOptions) => Promise<string[]>;
+export { createFindDirectories, };
+export type { FileSystemDependencies, FindDirectoriesOptions, };
+//# sourceMappingURL=find.d.ts.map

package/src/find.js

@@ -0,0 +1,62 @@
+import { resolve, join } from "node:path";
+/**
+ * Factory that produces an async findDirectories function with
+ * injected filesystem dependencies for full testability.
+ */
+function createFindDirectories(deps) {
+    const { readdir } = deps;
+    return async function findDirectories(root, options = {}) {
+        const { maxDepth = 1, allowlist, blocklist } = options;
+        const absRoot = resolve(root);
+        const results = [];
+        function isAllowed(absPath, name) {
+            if (allowlist) {
+                if (Array.isArray(allowlist)) {
+                    if (!allowlist.includes(name))
+                        return false;
+                }
+                else if (!allowlist(absPath, name)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        function isBlocked(absPath, name) {
+            if (blocklist) {
+                if (Array.isArray(blocklist)) {
+                    if (blocklist.includes(name))
+                        return true;
+                }
+                else if (blocklist(absPath, name)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        async function walk(currentPath, depth) {
+            if (depth > maxDepth)
+                return;
+            const entries = await readdir(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const childPath = resolve(join(currentPath, entry.name));
+                let isDirectory = entry.isDirectory();
+                if (!isDirectory)
+                    continue;
+                if (isBlocked(childPath, entry.name))
+                    continue;
+                if (!isAllowed(childPath, entry.name))
+                    continue;
+                results.push(childPath);
+                if (depth < maxDepth) {
+                    await walk(childPath, depth + 1);
+                }
+            }
+        }
+        // match find(1): root is always included
+        results.push(absRoot);
+        await walk(absRoot, 1);
+        return results;
+    };
+}
+export { createFindDirectories, };
+//# sourceMappingURL=find.js.map

package/src/find.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=find.test.d.ts.map

package/src/find.test.js

@@ -0,0 +1,127 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createFindDirectories } from "./find.js";
+// Helper to build Dirent-like objects
+function dir(name) {
+    return { name, isDirectory: () => true };
+}
+function file(name) {
+    return { name, isDirectory: () => false };
+}
+test("find: findDirectories success", async () => {
+    // Minimal mock FS: /root contains one directory "a" and one file "b"
+    const mockFS = {
+        readdir: async (path) => {
+            if (path === "/root") {
+                return [
+                    { name: "a", isDirectory: () => true },
+                    { name: "b", isDirectory: () => false },
+                ];
+            }
+            return [];
+        },
+        stat: async (path) => ({
+            isDirectory: () => path === "/root" || path === "/root/a"
+        }),
+    };
+    const findDirectories = createFindDirectories(mockFS);
+    const result = await findDirectories("/root", { maxDepth: 1 });
+    assert.deepEqual(result, [
+        "/root",
+        "/root/a"
+    ]);
+});
+test("find: findDirectories symlink is NOT treated as a directory", async () => {
+    const mockFS = {
+        readdir: async (path) => {
+            if (path === "/root") {
+                return [
+                    {
+                        name: "linkToA",
+                        isDirectory: () => false
+                    }
+                ];
+            }
+            return [];
+        },
+        stat: async (path) => ({
+            isDirectory: () => path === "/root" // only root is a directory
+        }),
+        readlink: async () => {
+            throw new Error("readlink should not be called when symlink support is removed");
+        }
+    };
+    const findDirectories = createFindDirectories(mockFS);
+    const result = await findDirectories("/root", { maxDepth: 1 });
+    assert.deepEqual(result, [
+        "/root"
+    ]);
+});
+test("find: findDirectories at depth=2", async () => {
+    const calls = [];
+    const deps = {
+        readdir: async (path) => {
+            calls.push(path);
+            switch (path) {
+                case "/root":
+                    return [dir("a"), dir("b"), file("ignore.txt")];
+                case "/root/a":
+                    return [dir("a1")];
+                case "/root/b":
+                    return [dir("b1")];
+                default:
+                    return [];
+            }
+        },
+        stat: async (_) => ({
+            isDirectory: () => false
+        })
+    };
+    const find = createFindDirectories(deps);
+    const result = await find("/root", { maxDepth: 2 });
+    assert.deepEqual(result.sort(), [
+        "/root",
+        "/root/a",
+        "/root/b",
+        "/root/a/a1",
+        "/root/b/b1"
+    ].sort());
+});
+test("find: findDirectories at depth=3", async () => {
+    const calls = [];
+    const deps = {
+        readdir: async (path) => {
+            calls.push(path);
+            switch (path) {
+                case "/root":
+                    return [dir("a"), dir("b")];
+                case "/root/a":
+                    return [dir("a1")];
+                case "/root/b":
+                    return [dir("b1")];
+                case "/root/a/a1":
+                case "/root/b/b1":
+                    return [dir("c")];
+                case "/root/b/b1/c":
+                    return [dir("d"), file("fd")];
+                default:
+                    return [];
+            }
+        },
+        stat: async (_) => ({
+            isDirectory: () => false
+        })
+    };
+    const find = createFindDirectories(deps);
+    const result = await find("/root", { maxDepth: 3 });
+    assert.deepEqual(result.sort(), [
+        "/root",
+        "/root/a",
+        "/root/b",
+        "/root/a/a1",
+        "/root/a/a1/c",
+        "/root/b/b1",
+        "/root/b/b1/c",
+    ].sort());
+});
+//# sourceMappingURL=find.test.js.map

package/src/find.test.ts

@@ -0,0 +1,156 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { createFindDirectories } from "./find.js";
+
+import type { FileSystemDependencies } from "./find.js";
+
+// Helper to build Dirent-like objects
+function dir(name: string): { name: string; isDirectory(): boolean } {
+    return { name, isDirectory: () => true };
+}
+function file(name: string): { name: string; isDirectory(): boolean } {
+    return { name, isDirectory: () => false };
+}
+
+test("find: findDirectories success", async () => {
+
+    // Minimal mock FS: /root contains one directory "a" and one file "b"
+    const mockFS = {
+        readdir: async (path: string) => {
+            if (path === "/root") {
+                return [
+                    { name: "a", isDirectory: () => true },
+                    { name: "b", isDirectory: () => false },
+                ];
+            }
+            return [];
+        },
+
+        stat: async (path: string) => ({
+            isDirectory: () => path === "/root" || path === "/root/a"
+        }),
+    };
+
+    const findDirectories = createFindDirectories(mockFS);
+
+    const result = await findDirectories("/root", { maxDepth: 1 });
+
+    assert.deepEqual(result, [
+        "/root",
+        "/root/a"
+    ]);
+});
+
+test("find: findDirectories symlink is NOT treated as a directory", async () => {
+
+    const mockFS = {
+        readdir: async (path: string) => {
+            if (path === "/root") {
+                return [
+                    {
+                        name: "linkToA",
+                        isDirectory: () => false
+                    }
+                ];
+            }
+            return [];
+        },
+
+        stat: async (path: string) => ({
+            isDirectory: () => path === "/root" // only root is a directory
+        }),
+
+        readlink: async () => {
+            throw new Error("readlink should not be called when symlink support is removed");
+        }
+    };
+
+    const findDirectories = createFindDirectories(mockFS);
+
+    const result = await findDirectories("/root", { maxDepth: 1 });
+
+    assert.deepEqual(result, [
+        "/root"
+    ]);
+});
+
+
+test("find: findDirectories at depth=2", async () => {
+    const calls: string[] = [];
+
+    const deps: FileSystemDependencies = {
+        readdir: async (path: string): Promise<{ name: string; isDirectory(): boolean }[]> => {
+            calls.push(path);
+
+            switch (path) {
+                case "/root":
+                    return [dir("a"), dir("b"), file("ignore.txt")];
+                case "/root/a":
+                    return [dir("a1")];
+                case "/root/b":
+                    return [dir("b1")];
+                default:
+                    return [];
+            }
+        },
+        stat: async (_: string) => ({
+            isDirectory: () => false
+        })
+    };
+
+    const find = createFindDirectories(deps);
+
+    const result = await find("/root", { maxDepth: 2 });
+
+    assert.deepEqual(result.sort(), [
+        "/root",
+        "/root/a",
+        "/root/b",
+        "/root/a/a1",
+        "/root/b/b1"
+    ].sort());
+});
+
+test("find: findDirectories at depth=3", async () => {
+    const calls: string[] = [];
+
+    const deps: FileSystemDependencies = {
+        readdir: async (path: string): Promise<{ name: string; isDirectory(): boolean }[]> => {
+            calls.push(path);
+
+            switch (path) {
+                case "/root":
+                    return [dir("a"), dir("b")];
+                case "/root/a":
+                    return [dir("a1")];
+                case "/root/b":
+                    return [dir("b1")];
+                case "/root/a/a1":
+                case "/root/b/b1":
+                    return [dir("c")];
+                case "/root/b/b1/c":
+                    return [dir("d"), file("fd")]
+                default:
+                    return [];
+            }
+        },
+        stat: async (_: string) => ({
+            isDirectory: () => false
+        })
+    };
+
+    const find = createFindDirectories(deps);
+
+    const result = await find("/root", { maxDepth: 3 });
+
+    assert.deepEqual(result.sort(), [
+        "/root",
+        "/root/a",
+        "/root/b",
+        "/root/a/a1",
+        "/root/a/a1/c",
+        "/root/b/b1",
+        "/root/b/b1/c",
+    ].sort());
+});

package/src/find.ts

@@ -0,0 +1,99 @@
+import { resolve, join } from "node:path";
+
+interface FileSystemDependencies {
+    readdir: (path: string, opts: { withFileTypes: true }) => Promise<{ name: string; isDirectory(): boolean; }[]>;
+    stat: (path: string) => Promise<{ isDirectory(): boolean }>;
+}
+
+interface FindDirectoriesOptions {
+    maxDepth?: number;
+    followSymlinks?: boolean;
+    allowlist?: string[] | ((absPath: string, name: string) => boolean);
+    blocklist?: string[] | ((absPath: string, name: string) => boolean);
+}
+
+/**
+ * Factory that produces an async findDirectories function with
+ * injected filesystem dependencies for full testability.
+ */
+function createFindDirectories(deps: FileSystemDependencies) {
+
+    const { readdir } = deps;
+
+    return async function findDirectories(
+        root: string,
+        options: FindDirectoriesOptions = {}
+    ): Promise<string[]> {
+
+        const {
+            maxDepth = 1,
+            allowlist,
+            blocklist
+        } = options;
+
+        const absRoot = resolve(root);
+        const results: string[] = [];
+
+
+        function isAllowed(absPath: string, name: string): boolean {
+            if (allowlist) {
+                if (Array.isArray(allowlist)) {
+                    if (!allowlist.includes(name)) return false;
+                } else if (!allowlist(absPath, name)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        function isBlocked(absPath: string, name: string): boolean {
+            if (blocklist) {
+                if (Array.isArray(blocklist)) {
+                    if (blocklist.includes(name)) return true;
+                } else if (blocklist(absPath, name)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        async function walk(currentPath: string, depth: number): Promise<void> {
+            if (depth > maxDepth) return;
+
+            const entries = await readdir(currentPath, { withFileTypes: true });
+
+            for (const entry of entries) {
+                const childPath = resolve(join(currentPath, entry.name));
+
+                let isDirectory = entry.isDirectory();
+
+                if (!isDirectory) continue;
+
+                if (isBlocked(childPath, entry.name)) continue;
+                if (!isAllowed(childPath, entry.name)) continue;
+
+                results.push(childPath);
+
+                if (depth < maxDepth) {
+                    await walk(childPath, depth + 1);
+                }
+            }
+        }
+
+        // match find(1): root is always included
+        results.push(absRoot);
+
+        await walk(absRoot, 1);
+
+        return results;
+    };
+}
+
+export {
+    createFindDirectories,
+}
+
+export type {
+    FileSystemDependencies,
+    FindDirectoriesOptions,
+}

package/src/index.d.ts

@@ -1,4 +1,7 @@
 import { hello } from "./hello.js";
 import { pojo } from "./pojo.js";
-export { hello, pojo };
+import type { FindDirectoriesOptions, FileSystemDependencies } from "./find.js";
+import { createFindDirectories } from "./find.js";
+export { hello, pojo, createFindDirectories };
+export type { FindDirectoriesOptions, FileSystemDependencies, };
 //# sourceMappingURL=index.d.ts.map

package/src/index.js

@@ -1,4 +1,5 @@
 import { hello } from "./hello.js";
 import { pojo } from "./pojo.js";
-export { hello, pojo };
+import { createFindDirectories } from "./find.js";
+export { hello, pojo, createFindDirectories };
 //# sourceMappingURL=index.js.map

package/src/index.ts

@@ -1,7 +1,15 @@
 import { hello } from "./hello.js";
 import { pojo } from "./pojo.js";
+import type { FindDirectoriesOptions, FileSystemDependencies } from "./find.js";
+import { createFindDirectories } from "./find.js";
 
 export {
     hello,
-    pojo
+    pojo,
+    createFindDirectories
 };
+
+export type {
+    FindDirectoriesOptions,
+    FileSystemDependencies,
+}

package/docs/docs.json

@@ -1,300 +0,0 @@
-{
-	"schemaVersion": "2.0",
-	"id": 0,
-	"name": "@wtasnorg/node-lib",
-	"variant": "project",
-	"kind": 1,
-	"flags": {},
-	"children": [
-		{
-			"id": 1,
-			"name": "hello",
-			"variant": "declaration",
-			"kind": 64,
-			"flags": {},
-			"sources": [
-				{
-					"fileName": "hello.ts",
-					"line": 6,
-					"character": 15,
-					"url": "https://github.com/wtasg/node-lib/blob/890fd5e866d9096470d56594a5788bf55e34bf7c/src/hello.ts#L6"
-				}
-			],
-			"signatures": [
-				{
-					"id": 2,
-					"name": "hello",
-					"variant": "signature",
-					"kind": 4096,
-					"flags": {},
-					"comment": {
-						"summary": [
-							{
-								"kind": "text",
-								"text": "A sample function that should work to test if lib is installed correctly."
-							}
-						],
-						"blockTags": [
-							{
-								"tag": "@returns",
-								"content": [
-									{
-										"kind": "text",
-										"text": "hello message"
-									}
-								]
-							}
-						]
-					},
-					"sources": [
-						{
-							"fileName": "hello.ts",
-							"line": 6,
-							"character": 15,
-							"url": "https://github.com/wtasg/node-lib/blob/890fd5e866d9096470d56594a5788bf55e34bf7c/src/hello.ts#L6"
-						}
-					],
-					"type": {
-						"type": "reference",
-						"target": {
-							"packageName": "typescript",
-							"packagePath": "lib/lib.es5.d.ts",
-							"qualifiedName": "Promise"
-						},
-						"typeArguments": [
-							{
-								"type": "intrinsic",
-								"name": "string"
-							}
-						],
-						"name": "Promise",
-						"package": "typescript"
-					}
-				}
-			]
-		},
-		{
-			"id": 3,
-			"name": "pojo",
-			"variant": "declaration",
-			"kind": 64,
-			"flags": {},
-			"sources": [
-				{
-					"fileName": "pojo.ts",
-					"line": 10,
-					"character": 9,
-					"url": "https://github.com/wtasg/node-lib/blob/890fd5e866d9096470d56594a5788bf55e34bf7c/src/pojo.ts#L10"
-				}
-			],
-			"signatures": [
-				{
-					"id": 4,
-					"name": "pojo",
-					"variant": "signature",
-					"kind": 4096,
-					"flags": {},
-					"comment": {
-						"summary": [
-							{
-								"kind": "text",
-								"text": "Convert a class instance into a plain JavaScript object.\nCopies only the instance's own enumerable data properties\nand excludes methods or prototype values."
-							}
-						],
-						"blockTags": [
-							{
-								"tag": "@returns",
-								"content": [
-									{
-										"kind": "text",
-										"text": "A plain JavaScript object containing only data fields."
-									}
-								]
-							}
-						]
-					},
-					"sources": [
-						{
-							"fileName": "pojo.ts",
-							"line": 10,
-							"character": 9,
-							"url": "https://github.com/wtasg/node-lib/blob/890fd5e866d9096470d56594a5788bf55e34bf7c/src/pojo.ts#L10"
-						}
-					],
-					"typeParameters": [
-						{
-							"id": 5,
-							"name": "T",
-							"variant": "typeParam",
-							"kind": 131072,
-							"flags": {},
-							"type": {
-								"type": "intrinsic",
-								"name": "object"
-							}
-						}
-					],
-					"parameters": [
-						{
-							"id": 6,
-							"name": "instance",
-							"variant": "param",
-							"kind": 32768,
-							"flags": {},
-							"comment": {
-								"summary": [
-									{
-										"kind": "text",
-										"text": "A class instance to convert."
-									}
-								]
-							},
-							"type": {
-								"type": "reference",
-								"target": 5,
-								"name": "T",
-								"package": "@wtasnorg/node-lib",
-								"refersToTypeParameter": true
-							}
-						}
-					],
-					"type": {
-						"type": "reference",
-						"target": {
-							"packageName": "typescript",
-							"packagePath": "lib/lib.es5.d.ts",
-							"qualifiedName": "Record"
-						},
-						"typeArguments": [
-							{
-								"type": "intrinsic",
-								"name": "string"
-							},
-							{
-								"type": "intrinsic",
-								"name": "any"
-							}
-						],
-						"name": "Record",
-						"package": "typescript"
-					}
-				}
-			]
-		}
-	],
-	"groups": [
-		{
-			"title": "Functions",
-			"children": [
-				1,
-				3
-			]
-		}
-	],
-	"packageName": "@wtasnorg/node-lib",
-	"readme": [
-		{
-			"kind": "text",
-			"text": "# @wtasnorg/node-lib\n\nA library project for nodejs. #nodejs #typescript #library\n\n- [npm org](https://www.npmjs.com/org/wtasnorg)\n- [github repo](https://github.com/wtasg/node-lib)\n\n## Functions\n\n1. hello (for debugging)\n2. "
-		},
-		{
-			"kind": "code",
-			"text": "`pojo`"
-		},
-		{
-			"kind": "text",
-			"text": " for converting class objects to Plain Old Javascript Objects.\n\n## Develop\n\n"
-		},
-		{
-			"kind": "code",
-			"text": "```bash\ngit clone git@github.com:wtasg/node-lib.git\nnpm run build\nnpm run test\n# make changes...\n```"
-		},
-		{
-			"kind": "text",
-			"text": "\n\nWe are using "
-		},
-		{
-			"kind": "code",
-			"text": "`node --test`"
-		},
-		{
-			"kind": "text",
-			"text": " for testing.\n\n## Install and Usage\n\n"
-		},
-		{
-			"kind": "code",
-			"text": "```bash\nnpm install @wtasnorg/node-lib\n```"
-		},
-		{
-			"kind": "text",
-			"text": "\n\n"
-		},
-		{
-			"kind": "code",
-			"text": "```typescript\n# check if you can run code\nimport {hello} from \"@wtasnorg/node-lib\";\n\nawait hello(); \n// \"hello from @wtasnorg/node-lib\"\n```"
-		},
-		{
-			"kind": "text",
-			"text": "\n\n## License: MIT\n\n[MIT License file]("
-		},
-		{
-			"kind": "relative-link",
-			"text": "LICENSE",
-			"target": 2
-		},
-		{
-			"kind": "text",
-			"text": ")"
-		}
-	],
-	"symbolIdMap": {
-		"0": {
-			"packageName": "@wtasnorg/node-lib",
-			"packagePath": "src/index.ts",
-			"qualifiedName": ""
-		},
-		"1": {
-			"packageName": "@wtasnorg/node-lib",
-			"packagePath": "src/hello.ts",
-			"qualifiedName": "hello"
-		},
-		"2": {
-			"packageName": "@wtasnorg/node-lib",
-			"packagePath": "src/hello.ts",
-			"qualifiedName": "hello"
-		},
-		"3": {
-			"packageName": "@wtasnorg/node-lib",
-			"packagePath": "src/pojo.ts",
-			"qualifiedName": "pojo"
-		},
-		"4": {
-			"packageName": "@wtasnorg/node-lib",
-			"packagePath": "src/pojo.ts",
-			"qualifiedName": "pojo"
-		},
-		"5": {
-			"packageName": "@wtasnorg/node-lib",
-			"packagePath": "src/pojo.ts",
-			"qualifiedName": "T"
-		},
-		"6": {
-			"packageName": "@wtasnorg/node-lib",
-			"packagePath": "src/pojo.ts",
-			"qualifiedName": "instance"
-		}
-	},
-	"files": {
-		"entries": {
-			"1": "src/index.ts",
-			"2": "LICENSE",
-			"3": "README.md",
-			"4": ""
-		},
-		"reflections": {
-			"1": 0,
-			"3": 0,
-			"4": 0
-		}
-	}
-}