vivth 1.4.10 → 1.5.1

package/src/doc/JSautoDOC.mjs

@@ -1,36 +1,34 @@
 // @ts-check
 
-import { extname, join } from 'node:path';
+import { extname } from 'node:path';
 import { readFile } from 'node:fs/promises';
 
 import prettier from 'prettier';
-import chokidar from 'chokidar';
 
-import { EventSignal } from '../class/EventSignal.mjs';
-import { parsedFile } from './parsedFile.mjs';
-import { SafeExit } from '../class/SafeExit.mjs';
-import { Effect } from '../class/Effect.mjs';
+import { FileSafe } from '../class/FileSafe.mjs';
+import { ForEach } from '../class/ForEach.mjs';
+import { FSDirArchWatcher } from '../class/FSDirArchWatcher.mjs';
+import { JSONFileHandler } from '../class/JSONFileHandler.mjs';
 import { Paths } from '../class/Paths.mjs';
-import { Signal } from '../class/Signal.mjs';
+import { IsSameFile } from '../function/IsSameFile.mjs';
 import { LazyFactory } from '../function/LazyFactory.mjs';
 import { TryAsync } from '../function/TryAsync.mjs';
-import { Console } from '../class/Console.mjs';
+import { parsedFileForDOC } from './parsedFileForDOC.mjs';
+import { Preferrence } from '../common/Preferrence.mjs';
+import { basename, join } from 'node:path';
 import { TsToMjs } from '../function/TsToMjs.mjs';
-import { FileSafe } from '../class/FileSafe.mjs';
+import { Console } from '../class/Console.mjs';
 import { correctBeforeParse } from './correctBeforeParse.mjs';
+import { GetterSetter } from '../class/GetterSetter.mjs';
+import { ForOfSync } from '../function/ForOfSync.mjs';
+import { TryNew } from '../function/TryNew.mjs';
+import { cleanPreserveTypedef } from './cleanPreserveTypedef.mjs';
+
+export const multiExportEntryPointsPath = './generated/vivth/exports/';
 
 /**
- * @typedef {import('fs').Stats} Stats
- */
-/**
- * @type {BufferEncoding}
- */
-const encoding = 'utf-8';
-const readmesrcname = 'README.src.md';
-/**
- * @type {Set<import('../types/ExtnameType.mjs').ExtnameType>}
+ * @typedef {import('../typehints/VivthCleanup.mjs').VivthCleanup} VivthCleanup
  */
-const acceptableExt = new Set(['.mjs', '.mts', '.ts']);
 
 /**
  * @description
@@ -54,358 +52,749 @@ const acceptableExt = new Set(['.mjs', '.mts', '.ts']);
  * >>- static/instance method with generic template;
  * >7) transpile `.ts` and `.mts` to `.mjs` with same name and directory;
  * >>- use `"at"preserve` to preserve tsdoc comment section;
+ * >8) integrated with assembly script to wasm compiler on the doc;
+ * >>- see [AssemblyScript](#assemblyscript);
+ * >9) modify following root json files:
+ * >>- `package.json`: assign `exports`, `main`, `module`;
+ * >>- `tsconfig.json`: assign `includes`, anything passed on `options.jstsconfigs`;
+ * >>- `jsconfig.json`: assign `includes`, anything passed on `options.jstsconfigs`;
+ * >10) generates files to `/generated/vivth/exports/`:
+ * >>- `./browser.mjs`: able to be called on `browser` platform;
+ * >>- `./node.mjs`:  able to be called on `node` platform;
+ * >>- `./neutral.mjs`: able to be called on `node` and `browser` platform;
+ * >>- `./unsupported.mjs`: most likely will throw error when called, it is more of a logged error to be managed;
+ * >>- `./all.mjs`: collections of all platform;
+ * >11) doesn't support accessor;
+ * >>- due to how TLS way accessor type not casting its getter and setter working around accessor requires ignoring this specific error, and it might become ugly real quick;
+ * >>- we recomend to stick with getter and setter;
+ * - for runtime example see file `/dev/auto-doc.mjs` on source code;
+ * @implements {VivthCleanup}
  */
 export class JSautoDOC {
+	vivthCleanup = async () => {
+		await this.watcher?.vivthCleanup();
+	};
+	/**
+	 * @typedef {'readme' |
+	 *  'handledJS'
+	 * } returnTypeStringType
+	 */
+	/**
+	 * @typedef {FSDirArchWatcher<{
+	 *     path: string;
+	 *     parsed: undefined;
+	 *     ext: `.${string}`;
+	 *     type: returnTypeStringType;
+	 *     readme?:string;
+	 * } | {
+	 *     path: string;
+	 *     parsed: parsedFileForDOC;
+	 *     ext: string;
+	 *     type: returnTypeStringType;
+	 *     readme?:string;
+	 * }>} FSDirArchWatcher__
+	 */
 	/**
 	 * @type {JSautoDOC|undefined}
 	 */
 	static #instance;
 	/**
 	 * @description
-	 * @param {Object} [options]
-	 * @param {Object} [options.paths]
-	 * @param {string} options.paths.file
-	 * - entry point;
-	 * @param {string} options.paths.readMe
-	 * - readme target;
-	 * @param {string} options.paths.dir
+	 * @param {Object} options
+	 * @param {string} options.src
 	 * - source directory;
 	 * @param {string} [options.copyright]
 	 * @param {string} [options.tableOfContentTitle]
-	 * @param {import('chokidar').ChokidarOptions} [options.option]
+	 * @param {number} [options.maxDebounceForGeneratingDocAndExport]
+	 * - default `10_000`;
+	 * @param {import('chokidar').ChokidarOptions} [options.chokidarOptions]
 	 * - ChokidarOptions;
+	 * @param {import('../typehints/AutoDocASOptions.mjs').AutoDocASOptions} [options.assemblyScriptOptions]
+	 * - abstracted details to handle `.as.ts` file;
+	 * @param {(arg0:{map:Map<string, {
+	 *     path: string;
+	 *     parsed: undefined;
+	 *     ext: `.${string}`;
+	 *     type: returnTypeStringType;
+	 *     readme?:string;
+	 * } | {
+	 *     path: string;
+	 *     parsed: parsedFileForDOC;
+	 *     ext: string;
+	 *     type: returnTypeStringType;
+	 *     readme?:string;
+	 * }>})=>Promise<void>} [options.onLastGeneratedCallback]
+	 * - callback to be run on finishing generating document AND exports;
+	 * - only handle that marked as `isLastCalled`;
+	 * @param { import('typescript').CompilerOptions |
+	 * 	import('typescript').ParsedCommandLine
+	 * } [options.jstsconfigs]
+	 * - type of `ts/jsconfig` to be assigned to existing respective `.json` file;
 	 * @example
-	 * import { JSautoDOC } from 'vivth';
+	 * import { JSautoDOC } from 'vivth/node';
 	 *
-	 *  new JSautoDOC({
-	 * 	paths: { dir: 'src', file: 'index.mjs', readMe: 'README.md' },
+	 * new JSautoDOC({
+	 * 	src: '/src',
 	 * 	copyright: 'this library is made and distributed under MIT license;',
 	 * 	tableOfContentTitle: 'list of exported API and typehelpers',
+	 * 	// assemblyScriptOptions: {},
+	 * 	// onLastGeneratedCallback: async (options) => {
+	 * 	// 	Console.log(options);
+	 * 	// },
 	 * });
-	 *
 	 */
 	constructor({
-		paths = { dir: './src', file: './index.mjs', readMe: './README.md' },
+		src = './src',
+		onLastGeneratedCallback = undefined,
 		tableOfContentTitle = 'exported-api-and-type-list',
 		copyright = '',
-		option = {},
-	} = {}) {
+		maxDebounceForGeneratingDocAndExport = 10_000,
+		assemblyScriptOptions = undefined,
+		chokidarOptions = undefined,
+		jstsconfigs = undefined,
+	}) {
 		if (JSautoDOC.#instance instanceof JSautoDOC) {
-			return this;
+			return JSautoDOC.#instance;
 		}
 		JSautoDOC.#instance = this;
+		this.#onLastGeneratedCallback = onLastGeneratedCallback;
 		this.#tableOfContentTitle = tableOfContentTitle;
-		this.#paths = paths;
+		this.#source = src;
 		this.#copyright = copyright;
-		const rootPath = Paths.root;
-		if (rootPath === undefined) {
+		this.#assemblyScriptOptions = assemblyScriptOptions;
+		this.#readmePath = Paths.diskAbsolute('/README.src.md');
+		Promise.all([
+			this.#jstsConfigAddInclude('/tsconfig.json', jstsconfigs),
+			this.#jstsConfigAddInclude('/jsconfig.json', jstsconfigs),
+		]);
+		FileSafe.exist(this.#readmePath).then(async (isExist) => {
+			if (isExist) {
+				return;
+			}
+			await this.#writeREADMEDefaultSRC();
+		});
+		const [fsDirArchWatcher, errorfsDirArchWatcherInstance] = TryNew(
+			FSDirArchWatcher,
+			[src, this.#readmePath],
+			{
+				debounce: maxDebounceForGeneratingDocAndExport,
+				chokidarOptions,
+				/**
+				 * @type {FSDirArchWatcher__["eachHandler"]}
+				 */
+				each: async (eventName, path, stats) => {
+					/**
+					 * @type {`.${string}`}
+					 */
+					// @ts-expect-error
+					const ext = extname(path);
+					const readMeHandled = await this.checkReadmeFile(path);
+					if (readMeHandled.isBeingHandled) {
+						return { path, parsed: undefined, readme: readMeHandled.content, ext, type: 'readme' };
+					}
+					if (!this.#acceptableExt.has(ext)) {
+						throw '';
+					}
+					if (basename(path).endsWith(`.d${ext}`)) {
+						const renamedPath = path.replace(new RegExp(`.d${ext}$`), ext);
+						await FileSafe.rename(path, renamedPath);
+						throw '';
+					}
+					switch (eventName) {
+						case 'add':
+						case 'change':
+							if (ext !== '.mjs') {
+								await TsToMjs(path, {
+									encoding: Preferrence.encoding,
+									assemblyScriptOptions: this.#assemblyScriptOptions,
+								});
+								throw '';
+							}
+							if (!stats?.isFile()) {
+								throw '';
+							}
+							if (await FileSafe.exist(path.replace(/.mjs$/, '.mts'))) {
+								const newString = cleanPreserveTypedef(
+									await readFile(path, { encoding: Preferrence.encoding }),
+								);
+								if (newString) {
+									await FileSafe.write(path, newString, { encoding: Preferrence.encoding });
+								}
+							}
+							return await this.#addAndChangesHandler(ext, path, stats);
+						default:
+							/**
+							 * - auto deleted from the map so need to call `.delete`
+							 */
+							throw '';
+					}
+				},
+				// @ts-expect-error
+				full: this.#fullHandler,
+			},
+		);
+		if (errorfsDirArchWatcherInstance) {
+			Console.error({ errorfsDirArchWatcherInstance });
 			return;
 		}
-		const watchpath = join(rootPath, this.#paths.dir);
-		const watcher = chokidar.watch(watchpath, option);
-		const watcherReadme = chokidar.watch(join(rootPath, readmesrcname), option);
-		/**
-		 * @type {(eventName: import('chokidar/handler.js').EventName, path: string, stats?: import('fs').Stats) => void}
-		 */
-		const listener = (eventName, path, stats) => {
-			const ext = extname(path);
-			if (
-				acceptableExt.has(
-					// @ts-expect-error
-					ext
-				) === false
-			) {
+		this.watcher = fsDirArchWatcher;
+	}
+	/**
+	 * @type { FSDirArchWatcher<any>|undefined }
+	 */
+	watcher;
+	/**
+	 * @type {string}
+	 */
+	#source = './src';
+	#packageJSONHandler = LazyFactory(() => new JSONFileHandler('/package.json'));
+	/**
+	 * @type {Set<import('../typehints/ExtnameType.mjs').ExtnameType>}
+	 */
+	#acceptableExt = new Set(['.js', '.mjs', '.mts', '.ts']);
+	/**
+	 * @param {string} configPath
+	 * @param {ConstructorParameters<typeof JSautoDOC>[0]["jstsconfigs"]} jstsconfigs
+	 */
+	#jstsConfigAddInclude = async (configPath, jstsconfigs) => {
+		return await TryAsync(async () => {
+			if (!(await FileSafe.exist(Paths.diskAbsolute(configPath)))) {
 				return;
 			}
-			if (ext !== '.mjs') {
-				// no need to be awaited
-				TsToMjs(path, {
-					encoding,
-				});
+			const handler = new JSONFileHandler(configPath);
+			const [object, error] = await handler.read();
+			if (error) {
 				return;
 			}
-			switch (eventName) {
-				case 'add':
-				case 'change':
-					this.#addHandler(eventName, path, stats);
-					break;
-				case 'unlink':
-					this.#removeHandler(eventName, path, stats);
-					break;
+			const include =
+				// @ts-expect-error
+				new Set(object.include ?? []);
+			include.add(`.${Paths.normalizeForRoot(this.#source)}`);
+			include.add('./generated/vivth/exports');
+			const obj = { include: Array.from(include) };
+			if (!jstsconfigs) {
+				Object.assign(obj, jstsconfigs);
 			}
-		};
-		watcher.on('all', listener);
-		watcherReadme.on('all', this.#readMeListener);
-		if (SafeExit.instance) {
-			SafeExit.instance.addCallback(async () => {
-				watcher.close();
-				watcherReadme.close();
-				watcher.removeAllListeners();
-				watcherReadme.removeAllListeners();
-				watcher.removeListener('all', listener);
-				watcherReadme.removeAllListeners(this.#readMeListener);
-				watcherReadme.removeListener('all', this.#readMeListener);
-			});
-		}
-	}
+			await handler.assign(obj);
+		});
+	};
 	/**
-	 * @type {string|undefined}
+	 * @type {ConstructorParameters<typeof JSautoDOC>[0]["onLastGeneratedCallback"]}
 	 */
-	#copyright;
+	#onLastGeneratedCallback;
 	/**
-	 * @type {{
-	 *   file: string;
-	 *   readMe: string;
-	 *   dir: string;
-	 *	}|undefined}
+	 * @type {string|undefined}
 	 */
-	#paths;
+	#tableOfContentTitle;
 	/**
 	 * @type {string|undefined}
 	 */
-	#tableOfContentTitle;
+	#copyright;
 	/**
-	 * @param {import('chokidar/handler.js').EventName} _eventName
-	 * @param {string} path_
-	 * @param {Stats|undefined} stats
-	 * @returns {void}
+	 * @type {string}
 	 */
-	#readMeListener = (_eventName, path_, stats) => {
-		if (stats && stats.isFile() === false) {
-			return;
-		}
-		readFile(path_, { encoding }).then((content) => {
-			this.#readMESRCContent.value = content;
-		});
-	};
+	// @ts-expect-error
+	#readmePath;
 	/**
-	 * @type {Signal<Set<string>>}
+	 * @type { string }
 	 */
-	#filePaths = LazyFactory(() => new Signal(new Set()));
+	#readme = Paths.diskAbsolute('./README.md');
 	/**
-	 * @type {Signal<string>}
+	 * @type { import('../typehints/AutoDocASOptions.mjs').AutoDocASOptions|undefined }
 	 */
-	#readMESRCContent = LazyFactory(() => new Signal(''));
-	// @ts-expect-error
-	#generatedREADME_md = new Effect(async ({ subscribe, isLastCalled }) => {
-		const contentSRC = subscribe(this.#readMESRCContent).value;
-		const filepaths = subscribe(this.#filePaths).value;
-		if ((await isLastCalled(100)) === false || !contentSRC || !filepaths) {
-			return;
+	#assemblyScriptOptions;
+	/**
+	 * @param {string} path
+	 * @returns {Promise<{isBeingHandled:boolean, content?: string}>}
+	 * - is being handled;
+	 */
+	checkReadmeFile = async (path) => {
+		const isREADMEPATH = IsSameFile(this.#readmePath, path);
+		if (!isREADMEPATH) {
+			return { isBeingHandled: false };
 		}
-		const res = await this.#generateFromSRC(contentSRC, filepaths);
-		if ((await isLastCalled()) === false || res === undefined) {
-			return;
+		let content = '';
+		if (!(await FileSafe.exist(this.#readmePath))) {
+			await FileSafe.write(this.#readmePath, `README HEADER PLACEHOLDER`, {
+				encoding: Preferrence.encoding,
+			});
 		}
-		const { readme, mjsFile } = res;
-		const rootPath = Paths.root;
-		if (rootPath === undefined || this.#paths === undefined) {
-			return;
+		const [res] = await TryAsync(async () => {
+			return await readFile(path, { encoding: Preferrence.encoding });
+		});
+		if (!!res) {
+			content = res;
 		}
-		const readmePath = join(rootPath, this.#paths.readMe);
-		const mjsFilePath = join(rootPath, this.#paths.file);
-		const [[, errorWriteReadme], [, errorWriteMjsFile]] = await Promise.all([
-			FileSafe.write(readmePath, await prettier.format(readme, { parser: 'markdown' }), {
-				encoding,
-			}),
-			FileSafe.write(mjsFilePath, mjsFile, { encoding }),
-		]);
-		if (errorWriteReadme === undefined) {
-			Console.info({ vivthJSautoDOC: `successfully generate '${readmePath}'` });
-		} else {
-			Console.error({ vivthJSautoDOC: `unable to generate '${readmePath}'`, errorWriteReadme });
+		return { isBeingHandled: true, content };
+	};
+	/**
+	 * @param {`.${string}`} extentionName
+	 * @param {string} path
+	 * @param {import('fs').Stats} [stats]
+	 * @returns {Promise<{
+	 *     path: string;
+	 *     parsed: undefined;
+	 *     ext: `.${string}`;
+	 *     type: returnTypeStringType;
+	 * } | {
+	 *     path: string;
+	 *     parsed: parsedFileForDOC;
+	 *     ext: string;
+	 *     type: returnTypeStringType;
+	 * }>}
+	 */
+	#addAndChangesHandler = async (extentionName, path, stats) => {
+		const [checkCorrectBeforeParse, errorCorrectBeforeParse] = await TryAsync(async () => {
+			return await correctBeforeParse(path, Preferrence.encoding);
+		});
+		if (errorCorrectBeforeParse) {
+			Console.error({ errorCorrectBeforeParse }, { now: true });
+			throw '';
 		}
-		if (errorWriteMjsFile === undefined) {
-			Console.info({ vivthJSautoDOC: `successfully generate '${mjsFilePath}'` });
-		} else {
-			Console.error({ vivthJSautoDOC: `unable to generate '${mjsFilePath}'`, errorWriteMjsFile });
+		switch (checkCorrectBeforeParse) {
+			case 'shouldProceedNextCheck':
+				const parsed = new parsedFileForDOC(path, stats);
+				await parsed.parse();
+				return { ext: extentionName, parsed, path, type: 'handledJS' };
+			default:
+				throw '';
 		}
+	};
+	/**
+	 * @returns {Promise<void>}
+	 */
+	#writeREADMEDefaultSRC = async () => {
+		await this.#readmeSourceGetterSetter.set?.(`---\n---\n---\nREADME SRC PLACEHOLDER\n---\n---\n`);
+	};
+	#readmeSourceGetterSetter = new GetterSetter({
+		get: async () => {
+			return await readFile(this.#readmePath, { encoding: Preferrence.encoding });
+		},
+		/**
+		 * @param {string} content
+		 */
+		set: async (content) => {
+			await FileSafe.write(this.#readmePath, content, { encoding: Preferrence.encoding });
+		},
 	});
+
 	/**
-	 * @param {string} string
-	 * @returns {string}
+	 * @param { string } [exporter]
+	 * @param { string } [typedefString]
+	 * @returns { string }
 	 */
-	#generateJSDOCFromstring = (string) => {
-		return `\n/**\n * automatically generated by \`vivth.JSautoDOC\`\n * @copyright\n${string.replace(
-			/^/gm,
-			' * '
-		)}\n */\n`;
+	#generateSingularMJSExportAndType = (exporter, typedefString) => {
+		let content = '';
+		if (exporter) {
+			content += exporter ?? '';
+		}
+		if (exporter && typedefString) {
+			content += '\n';
+		}
+		if (typedefString) {
+			content += typedefString ?? '';
+		}
+		return content;
 	};
+
 	/**
-	 * @typedef { Object } generatedFromSRC
-	 * @property { string } readme
-	 * @property { string } mjsFile
+	 * @param { string[] } array
+	 * @returns { string[] }
 	 */
+	#cleanupArrayString = (array) => {
+		return array.filter((s) => s.trim() !== '');
+	};
+
 	/**
-	 * @param {string} contentSRC
-	 * @param {Set<string>} filepaths
-	 * @returns {Promise<generatedFromSRC|undefined>}
+	 * @param {[path: string, {
+	 *     path: string;
+	 *     parsed: undefined;
+	 *     ext: `.${string}`;
+	 *     type: returnTypeStringType;
+	 *     readme?: string;
+	 * } | {
+	 *     path: string;
+	 *     parsed: parsedFileForDOC;
+	 *     ext: string;
+	 *     type: returnTypeStringType;
+	 *     readme?: string;
+	 * }][]} array
+	 * @returns {Promise<{
+	 * 	readme:string,
+	 * 	platforms:{
+	 * 		node:string,
+	 * 		browser:string,
+	 * 		neutral:string,
+	 * 		unsupported:string,
+	 * 		all:string,
+	 * 	},
+	 * }|undefined>}
 	 */
-	#generateFromSRC = async (contentSRC, filepaths) => {
+	#generateFromSRC = async (array) => {
+		const contentSRC = (await this.#readmeSourceGetterSetter.get?.()) ?? '';
 		if (this.#tableOfContentTitle === undefined || this.#copyright === undefined) {
 			return;
 		}
 		const tableID = this.#tableOfContentTitle.replace(/\s+/g, '-').toLowerCase();
+		/**
+		 * @type { string[] }
+		 */
 		const tableOfContent = [];
+		/**
+		 * @type { string[] }
+		 */
 		const apiDocuments = [];
-		const mjsMain = ['// @ts-check', this.#generateJSDOCFromstring(this.#copyright)];
-		const mjsTypes = [];
-		const sortedFilepaths = [...filepaths].sort((a, b) => a.localeCompare(b));
-		for await (const path_ of sortedFilepaths) {
-			const {
-				documented,
-				content,
-				hasValidExportObject,
-				path: { relative: relativePath },
-				baseName: { noExt },
-			} = (await this.#parsedFilesRef.get(path_)).value;
-			const trueContent = await content.string();
-			if (trueContent === undefined) {
-				return;
-			}
-			const hasNoAutoDoc = /\/\*\*[\s\*]*?@noautodoc[\s\*]*?\*\//.test(trueContent);
-			if (hasValidExportObject) {
-				mjsMain.push(
-					`export { ${noExt} } from '${
-						relativePath.startsWith('.') ? relativePath : `./${relativePath}`
-					}';`
-				);
-			}
-			/**
-			 * @type {string[]}
-			 */
-			const currentDescription = [];
-			const { readme, typedef } = documented;
-			const [typedefString, error] = await TryAsync(async () => {
+		/**
+		 * @type { Array<string> }
+		 */
+		const all = [];
+		/**
+		 * @type { Array<string> }
+		 */
+		const node = [];
+		/**
+		 * @type { Array<string> }
+		 */
+		const browser = [];
+		/**
+		 * @type { Array<string> }
+		 */
+		const neutral = [];
+		/**
+		 * @type { Array<string> }
+		 */
+		const unsupported = [];
+
+		await Promise.all(
+			ForEach.array(array, async ([, { parsed }], i) => {
+				if (!parsed) {
+					return;
+				}
+				const {
+					documented,
+					content,
+					hasValidExportObject,
+					path: { relative: relativePath },
+					baseName: { noExt },
+					platform,
+				} = parsed;
+				const awaitedPlatform = await platform;
+				const trueContent = await content.string();
+				if (trueContent === undefined) {
+					return;
+				}
+				const hasNoAutoDoc = /\/\*\*[\s\*]*?@noautodoc[\s\*]*?\*\//.test(trueContent);
+				/**
+				 * @type { undefined|string }
+				 */
+				let comprehensiveExporter;
 				if (hasValidExportObject) {
-					throw new Error('');
+					comprehensiveExporter = `export { ${noExt} } from '${
+						relativePath.startsWith('.') ? relativePath : `./${relativePath}`
+					}';`;
 				}
-				const result = await typedef();
-				return result;
-			});
-			if (error === undefined && typedefString) {
-				mjsTypes.push(typedefString.module);
-				if (hasNoAutoDoc === false) {
-					const nameVarID = noExt.toLowerCase();
-					tableOfContent.push(`[${noExt}](#${nameVarID})`);
-					apiDocuments.push(
-						`<h2 id="${nameVarID}">${noExt}</h2>\n\n- jsdoc types:\n\n\`\`\`js\n${
-							typedefString.readme
-						}\n\`\`\`\n*) <sub>[go to ${this.#tableOfContentTitle}](#${tableID})</sub>`
+				/**
+				 * @type {string[]}
+				 */
+				const currentDescription = [];
+				const { readme, typedef } = documented;
+				const [typedefString] = await TryAsync(async () => {
+					if (hasValidExportObject) {
+						throw 'has no valid export object';
+					}
+					const result = await typedef();
+					return result;
+				});
+				/**
+				 * @type { undefined|string }
+				 */
+				let comprehensiveTypedefString;
+				if (typedefString) {
+					const typedefStringModule = typedefString.module;
+					comprehensiveTypedefString = typedefStringModule;
+					if (!hasNoAutoDoc) {
+						const nameVarID = noExt.toLowerCase();
+						tableOfContent[i] =
+							tableOfContent[i] ?? '' + `[${awaitedPlatform}.${noExt}](#${nameVarID})`;
+						apiDocuments[i] =
+							apiDocuments[i] ??
+							'' +
+								`<h2 id="${nameVarID}">${awaitedPlatform}.${noExt}</h2>\n\n- jsdoc types:\n\n\`\`\`js\n${
+									/** */
+									typedefString.readme.replace(/\[at\]/g, '@').replace(/\[blank\]/g, '[]')
+								}\n\`\`\`\n*) <sub>[go to ${this.#tableOfContentTitle}](#${tableID})</sub>\n\n---`;
+					}
+				}
+				if (!hasNoAutoDoc && hasValidExportObject) {
+					ForOfSync(
+						readme,
+						({
+							// fullDescription,
+							// instanceOrStatic,
+							// namedVar,
+							// typeOfVar,
+							parsedFullDescription,
+							reference,
+						}) => {
+							const { description, jsPreview } = parsedFullDescription;
+							currentDescription.push(
+								`\n#### reference: ${reference}\n${description}\n${jsPreview}`.replace(
+									/\[blank\]/g,
+									'',
+								),
+							);
+						},
 					);
+					const nameVarID = noExt.toLowerCase();
+					tableOfContent[i] =
+						tableOfContent[i] ?? '' + `[${awaitedPlatform}.${noExt}](#${noExt.toLowerCase()})`;
+					apiDocuments[i] =
+						apiDocuments[i] ??
+						'' +
+							`<h2 id="${nameVarID}">${awaitedPlatform}.${noExt}</h2>\n\n-current-description-to-replace-\n\n*) <sub>[go to ${
+								this.#tableOfContentTitle
+							}](#${tableID})</sub>\n\n---`.replace(
+								'-current-description-to-replace-',
+								currentDescription.join('\n'),
+							);
 				}
-			}
-			if (hasNoAutoDoc === false && hasValidExportObject) {
-				readme.forEach((ref) => {
-					const {
-						// fullDescription,
-						// instanceOrStatic,
-						// namedVar,
-						// typeOfVar,
-						parsedFullDescription,
-						reference,
-					} = ref;
-					const { description, jsPreview } = parsedFullDescription;
-					currentDescription.push(`\n#### reference:${reference}\n${description}\n${jsPreview}`);
-				});
-				const nameVarID = noExt.toLowerCase();
-				tableOfContent.push(`[${noExt}](#${noExt.toLowerCase()})`);
-				apiDocuments.push(
-					`<h2 id="${nameVarID}">${noExt}</h2>\n\n-current-description-to-replace-\n\n*) <sub>[go to ${
-						this.#tableOfContentTitle
-					}](#${tableID})</sub>`.replace(
-						'-current-description-to-replace-',
-						currentDescription.join('\n')
-					)
+
+				const collectedExportContent = this.#generateSingularMJSExportAndType(
+					comprehensiveExporter,
+					comprehensiveTypedefString,
 				);
-			}
-		}
+				if (collectedExportContent) {
+					all[i] = collectedExportContent;
+				}
+
+				switch (awaitedPlatform) {
+					case 'node':
+						{
+							if (collectedExportContent) {
+								node[i] = collectedExportContent;
+							}
+						}
+						break;
+					case 'browser':
+						{
+							if (collectedExportContent) {
+								browser[i] = collectedExportContent;
+							}
+						}
+						break;
+					case 'neutral':
+						{
+							if (collectedExportContent) {
+								neutral[i] = collectedExportContent;
+							}
+						}
+						break;
+					default:
+					case 'unsupported':
+						{
+							if (collectedExportContent) {
+								unsupported[i] = collectedExportContent;
+							}
+						}
+						break;
+				}
+			}),
+		);
 		const tableOfContentString = `<h2 id="${this.#tableOfContentTitle
 			.replace(/\s+/g, '-')
 			.toLowerCase()}">${
 			this.#tableOfContentTitle
-		}</h2>\n\n - -table-of-content-to-replace-\n\n-api-document-to-replace-`
-			.replace('-table-of-content-to-replace-', tableOfContent.join('\n - '))
-			.replace('-api-document-to-replace-', apiDocuments.join('\n\n'));
-		return {
-			mjsFile: [...mjsMain, ...mjsTypes].join('\n'),
-			readme: `${contentSRC}\n${tableOfContentString}`,
-		};
-	};
-	#parsedFilesRef = LazyFactory(() => {
-		const prefix = 'parsedFiles:';
+		}</h2>\n\n - -table-of-content-to-replace-\n\n---\n\n-api-document-to-replace-`
+			.replace(
+				'-table-of-content-to-replace-',
+				this.#cleanupArrayString(tableOfContent).join('\n - '),
+			)
+			.replace('-api-document-to-replace-', this.#cleanupArrayString(apiDocuments).join('\n\n'));
+
+		const readme = `${contentSRC}\n\n---\n\n${tableOfContentString}`;
+
 		return {
-			/**
-			 * @param {string} path__
-			 * @returns {Promise<Signal<parsedFile>>}
-			 */
-			get: async (path__) => {
-				const dispatch = (await EventSignal.get(`${prefix}${path__}`, false)).dispatch;
-				// @ts-expect-error
-				return dispatch;
-			},
-			/**
-			 * @param {string} path__
-			 * @returns {Promise<void>}
-			 */
-			unRef: async (path__) => {
-				const parsedFile = await this.#parsedFilesRef.get(`${prefix}${path__}`);
-				parsedFile.remove.ref();
+			readme,
+			platforms: {
+				all: this.#cleanupArrayString(all).join('\n'),
+				browser: this.#cleanupArrayString(browser).join('\n'),
+				neutral: this.#cleanupArrayString(neutral).join('\n'),
+				node: this.#cleanupArrayString(node).join('\n'),
+				unsupported: this.#cleanupArrayString(unsupported).join('\n'),
 			},
 		};
-	});
+	};
+
 	/**
-	 * @type {(eventName: 'add'|'change', path: string, stats?: import('fs').Stats) => void}
+	 * @param {string} name
+	 * @param {boolean} absolutePath
+	 * @returns {string}
 	 */
-	#addHandler = (eventName, path__, _stats) => {
-		TryAsync(async () => {
-			if (
-				//
-				!_stats?.isFile()
-			) {
-				return;
-			}
-			const res = await correctBeforeParse(path__, 'utf-8');
-			switch (res) {
-				case 'shouldProceedNextCheck':
-					const dispatch = await this.#parsedFilesRef.get(path__);
-					dispatch.value = new parsedFile(path__, _stats, encoding);
-					this.#filePaths.subscribers.notify(async ({ signalInstance }) => {
-						await dispatch.value.parse();
-						dispatch.subscribers.notify();
-						Console.info({ vivthJSautoDOC: `${eventName} '${path__}' to export and doc` });
-						signalInstance.value.add(path__);
-					});
-					break;
-				case 'waitForRewrite':
-				case 'doNotProcess':
-					break;
+	#generateExportPath = (name, absolutePath) => {
+		const rel = Paths.normalize(join(multiExportEntryPointsPath, `${name}.mjs`));
+		if (!absolutePath) {
+			if (!rel.startsWith('.')) {
+				return `./${rel}`;
 			}
-		}).then(([, error]) => {
-			if (error === undefined) {
-				return;
-			}
-			Console.error(error);
+			return rel;
+		}
+		return Paths.normalize(join(Paths.root, rel));
+	};
+
+	/**
+	 * @param {string} content
+	 * @returns {string}
+	 */
+	#generateExportMJSDOCFromstring = (content) => {
+		return `// @ts-check\n/**\n * automatically generated by \`JSautoDOC\`\n * @copyright\n${(
+			this.#copyright ?? ''
+		).replace(/^/gm, ' * ')}\n */\n${content}`;
+	};
+
+	/**
+	 * @param {string} name
+	 * @param {Object} [packageJSONObject]
+	 * @returns {void}
+	 */
+	#assignToPackageJSONExports = (name, packageJSONObject) => {
+		if (!packageJSONObject) {
+			return;
+		}
+		const relativePath = this.#generateExportPath(name, false);
+		if (name === 'all') {
+			Object.assign(packageJSONObject, { main: relativePath, module: relativePath });
+		}
+		Object.assign(packageJSONObject, {
+			exports: {
+				...// @ts-expect-error
+				(packageJSONObject.exports ?? {}),
+				[`.${Paths.normalizeForRoot(name)}`]: {
+					import: relativePath,
+					types: relativePath.replace('./', './generated/types/').replace(/\.mjs$/g, '.d.mts'),
+				},
+			},
 		});
 	};
+
 	/**
-	 * @type {(eventName: 'unlink', path: string, stats?: import('fs').Stats) => void}
+	 * @param {{
+	 * 		all:string,
+	 * 		node:string,
+	 * 		browser:string,
+	 * 		neutral:string,
+	 * 		unsupported:string,
+	 * 	}} platforms
+	 * @param {BufferEncoding} encoding
+	 * @param {any} packageJSONObject
+	 * @param {'node'|'browser'|'neutral'|'unsupported'} name
+	 * @returns {ReturnType<typeof TryAsync<void>>}
 	 */
-	#removeHandler = (eventName, path__, _stats) => {
-		TryAsync(async () => {
-			if (_stats?.isFile()) {
-				return true;
-			}
-			return false;
-		}).then(([, error]) => {
-			if (error === undefined) {
+	#generatePlatformsHandler = (platforms, encoding, packageJSONObject, name) => {
+		return TryAsync(async () => {
+			const path = this.#generateExportPath(name, true);
+			if (!platforms[name]) {
+				const [, errorRemovingPath] = await FileSafe.rm(path);
+				if (errorRemovingPath) {
+					return;
+				}
+				Console.info(
+					{
+						JSautoDOC: `✅ Successfully deleting '${path}' for having no valid exports`,
+					},
+					{
+						now: true,
+					},
+				);
 				return;
 			}
-			this.#filePaths.subscribers.notify(async ({ signalInstance }) => {
-				Console.warn({ [eventName]: path__ });
-				signalInstance.value.delete(path__);
-				await this.#parsedFilesRef.unRef(path__);
+			const content = this.#generateExportMJSDOCFromstring(platforms[name]);
+			this.#assignToPackageJSONExports(name, packageJSONObject);
+			await FileSafe.write(path, content, {
+				encoding,
 			});
+			Console.info(
+				{
+					JSautoDOC: `✅ Successfully write '${path}'`,
+				},
+				{
+					now: true,
+				},
+			);
 		});
 	};
+
+	/**
+	 * @type {FSDirArchWatcher__["fullHandler"]}
+	 */
+	#fullHandler = async ({ array, map }) => {
+		const readmePath = this.#readme;
+		Console.info(
+			{
+				JSautoDOC: `generating content for '${Paths.normalize(readmePath)}'`,
+			},
+			{
+				now: true,
+			},
+		);
+		const res = await this.#generateFromSRC(array);
+		if (!res) {
+			return;
+		}
+		const { readme, platforms } = res;
+		const [packageJSONObject] = await this.#packageJSONHandler.read();
+		const encoding = Preferrence.encoding;
+		const [promises_] = ForOfSync(
+			['all', 'browser', 'node', 'neutral', 'unsupported'],
+			async (key) => {
+				await this.#generatePlatformsHandler(
+					platforms,
+					encoding,
+					packageJSONObject,
+					// @ts-expect-error
+					key,
+				);
+			},
+		);
+		const [[, errorWriteReadme]] = await Promise.all([
+			TryAsync(async () => {
+				return await FileSafe.write(
+					readmePath,
+					await prettier.format(readme, { parser: 'markdown' }),
+					{
+						encoding,
+					},
+				);
+			}),
+			...promises_,
+		]);
+		if (!!packageJSONObject) {
+			await this.#packageJSONHandler.write(packageJSONObject);
+		}
+		if (errorWriteReadme === undefined) {
+			Console.info(
+				{
+					JSautoDOC: `✅ Successfully generate '${Paths.normalize(readmePath)}';`,
+				},
+				{
+					now: true,
+				},
+			);
+		}
+		if (errorWriteReadme) {
+			Console.error(
+				{
+					JSautoDOC: `❌ Unable to generate '${Paths.normalize(readmePath)}';`,
+					errorWriteReadme,
+				},
+				{
+					now: true,
+				},
+			);
+			return;
+		}
+		if (!this.#onLastGeneratedCallback) {
+			return;
+		}
+		await this.#onLastGeneratedCallback({ map });
+	};
 }