paralayer 1.0.5 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paralayer",
-  "version": "1.0.5",
+  "version": "1.1.0",
   "type": "module",
   "license": "MIT",
   "author": "imkost",
@@ -16,20 +16,18 @@
     "release": "sh -c 'npm version ${1:-patch} && npm run build && npm publish' --"
   },
   "bin": {
-    "paralayer": "bin.js"
+    "paralayer": "./src/bin.ts"
   },
   "exports": {
     ".": {
-      "default": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": "./src/index.ts"
     }
   },
   "files": [
-    "dist",
-    "bin.js"
+    "src"
   ],
   "dependencies": {
-    "@eposlabs/utils": "^1.0.0",
+    "@eposlabs/utils": "^1.0.13",
     "chokidar": "^4.0.3",
     "minimist": "^1.2.8"
   },

package/src/bin.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+
+import minimist from 'minimist'
+import { paralayer } from './index.ts'
+
+const argv = minimist(process.argv.slice(2), {
+  string: ['default'],
+  boolean: ['watch', 'globalize'],
+  default: { watch: false, default: null, globalize: false },
+})
+
+const paths = argv._
+const input = paths.slice(0, -1)
+const output = paths.at(-1)
+
+if (input.length === 0) {
+  console.error('[paralayer] Input directory is not provided')
+  process.exit(1)
+}
+
+if (!output) {
+  console.error('[paralayer] Output directory is not provided')
+  process.exit(1)
+}
+
+await paralayer({
+  input: input,
+  output: output,
+  watch: argv.watch,
+  default: argv.default,
+  globalize: argv.globalize,
+})

package/src/index.ts

@@ -0,0 +1,9 @@
+import { Paralayer, type Options } from './paralayer.ts'
+
+export async function paralayer(options: Options) {
+  const pl = new Paralayer(options)
+  await pl.start()
+  return await pl.readSetupJs()
+}
+
+export default paralayer

package/src/paralayer.ts

@@ -0,0 +1,268 @@
+import { Queue, safe, Unit } from '@eposlabs/utils'
+import type { FSWatcher } from 'chokidar'
+import { watch } from 'chokidar'
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { basename, extname, join, relative } from 'node:path'
+
+export type DirPath = string
+
+export type File = {
+  content: string
+  names: string[]
+}
+
+export type Options = {
+  input: DirPath | DirPath[]
+  output: DirPath
+  watch?: boolean
+  /** Default layer name. If a file name does not have layer tags, default name will be used. */
+  default?: string | null
+  /** Whether the layer variables should be exposed globally. */
+  globalize?: boolean
+}
+
+export class Paralayer extends Unit {
+  private files: { [path: string]: File | null } = {}
+  private options: Options
+  private started = false
+  private ready = false
+  private ready$ = Promise.withResolvers<void>()
+  private queue = new Queue()
+  private extensions = new Set(['.ts', '.tsx', '.js', '.jsx'])
+  private previousLayers: string[] = []
+  private watcher: FSWatcher | null = null
+
+  constructor(options: Options) {
+    super()
+    this.options = options
+  }
+
+  start = async () => {
+    if (this.started) return
+    this.started = true
+
+    await safe(rm(this.options.output, { recursive: true }))
+
+    this.watcher = watch(this.options.input)
+    this.watcher.on('all', this.onAll)
+    this.watcher.on('ready', this.onReady)
+
+    await this.ready$.promise
+    await this.queue.run(() => this.build())
+    if (!this.options.watch) await this.watcher.close()
+  }
+
+  async readSetupJs() {
+    const setupJsPath = join(this.options.output, 'setup.js')
+    return await readFile(setupJsPath, 'utf-8')
+  }
+
+  // ---------------------------------------------------------------------------
+  // HANDLERS
+  // ---------------------------------------------------------------------------
+
+  private onAll = async (event: string, path: string) => {
+    // Process only file events
+    if (!['add', 'change', 'unlink'].includes(event)) return
+
+    // Not supported file extension? -> Ignore
+    const ext = extname(path)
+    if (!this.extensions.has(ext)) return
+
+    // No layer in the file name? -> Ignore
+    if (!this.getLayer(path)) return
+
+    // Initial scan? -> Just register file
+    if (!this.ready) {
+      this.files[path] = null
+      return
+    }
+
+    // File removed? -> Remove and rebuild
+    if (event === 'unlink') {
+      delete this.files[path]
+      await this.queue.run(() => this.build())
+    }
+
+    // File added/changed? -> Reset its content and rebuild
+    if (event === 'add' || event === 'change') {
+      this.files[path] = null
+      await this.queue.run(() => this.build())
+    }
+  }
+
+  private onReady = async () => {
+    this.ready = true
+    this.ready$.resolve()
+  }
+
+  // ---------------------------------------------------------------------------
+  // BUILD
+  // ---------------------------------------------------------------------------
+
+  private async build() {
+    // Group file paths by layers
+    const paths = Object.keys(this.files)
+    if (paths.length === 0) return
+    const pathsByLayers = Object.groupBy(paths, path => this.getLayer(path))
+    const allLayers = Object.keys(pathsByLayers)
+
+    // Ensure output directory exists
+    await mkdir(this.options.output, { recursive: true })
+
+    // Ensure all files are read
+    await Promise.all(
+      paths.map(async path => {
+        if (this.files[path]) return
+        const content = await readFile(path, 'utf-8')
+        const names = this.extractExportedClassNames(content)
+        this.files[path] = { content, names }
+      }),
+    )
+
+    // Create layer files
+    for (const layer in pathsByLayers) {
+      // Generate layer.[layer].ts
+      const layerFile = join(this.options.output, `layer.${layer}.ts`)
+      const layerPaths = pathsByLayers[layer]!.toSorted()
+      const layerContent = this.generateLayerContent(layer, layerPaths)
+      await this.write(layerFile, layerContent)
+
+      // Top layer? -> Generate index.[layer].ts
+      if (this.isTopLayer(layer)) {
+        const indexFile = join(this.options.output, `index.${layer}.ts`)
+        const indexContent = this.generateIndexContent(layer, allLayers)
+        await this.write(indexFile, indexContent)
+      }
+    }
+
+    // Determine removed layers
+    const removedLayers = this.previousLayers.filter(l => !allLayers.includes(l))
+    this.previousLayers = allLayers
+
+    // Delete files of removed layers
+    for (const layer of removedLayers) {
+      // Delete layer file
+      const layerFile = join(this.options.output, `layer.${layer}.ts`)
+      await rm(layerFile)
+
+      // Top layer? -> Remove index file
+      if (this.isTopLayer(layer)) {
+        const indexFile = join(this.options.output, `index.${layer}.ts`)
+        await rm(indexFile)
+      }
+    }
+
+    // Generate setup.js file
+    const setupFile = join(this.options.output, 'setup.js')
+    const setupContent = this.generateSetupContent(allLayers)
+    await this.write(setupFile, setupContent)
+  }
+
+  // ---------------------------------------------------------------------------
+  // HELPERS
+  // ---------------------------------------------------------------------------
+
+  private extractExportedClassNames(content: string) {
+    if (content.includes('paralayer-ignore')) return []
+    return content
+      .split('export class ')
+      .slice(1)
+      .map(part => part.split(' ')[0].split('<')[0])
+  }
+
+  private generateLayerContent(layer: string, layerPaths: string[]) {
+    const $LayerName = this.getLayerName(layer, '$Pascal')
+    const $layerName = this.getLayerName(layer, '$camel')
+    const allNames = layerPaths.flatMap(path => this.files[path]?.names ?? [])
+
+    const imports = layerPaths
+      .map(path => {
+        const file = this.files[path]
+        if (!file) return ''
+        if (file.names.length === 0) return ''
+        const names = file.names
+        const types = file.names.map(name => `type ${name} as ${name}Type`)
+        const relativePath = relative(this.options.output, path)
+        return `import { ${[...names, ...types].join(', ')} } from '${relativePath}'`
+      })
+      .filter(Boolean)
+
+    const assign = [`Object.assign(${$layerName}, {`, ...allNames.map(name => `  ${name},`), `})`]
+
+    const globals = [
+      `declare global {`,
+      `  var ${$layerName}: ${$LayerName}`,
+      ``,
+      `  interface ${$LayerName} {`,
+      ...allNames.map(name => `    ${name}: typeof ${name}`),
+      `  }`,
+      ``,
+      `  namespace ${$layerName} {`,
+      ...allNames.map(name => `    export type ${name} = ${name}Type`),
+      `  }`,
+      `}`,
+    ]
+
+    return [...imports, '', ...assign, '', ...globals, ''].join('\n')
+  }
+
+  private generateIndexContent(topLayer: string, allLayers: string[]) {
+    const imports = allLayers
+      .filter(layer => layer.includes(topLayer))
+      .sort((layer1, layer2) => {
+        if (layer1.length !== layer2.length) return layer2.length - layer1.length
+        return layer1.localeCompare(layer2)
+      })
+      .map(layer => `import './layer.${layer}.ts'`)
+
+    return [...imports].join('\n')
+  }
+
+  private generateSetupContent(allLayers: string[]) {
+    const layers = allLayers.toSorted((layer1, layer2) => {
+      if (layer1.length !== layer2.length) return layer1.length - layer2.length
+      return layer1.localeCompare(layer2)
+    })
+
+    const vars = layers.map(layer => {
+      const $layerName = this.getLayerName(layer, '$camel')
+      if (this.options.globalize) return `globalThis.${$layerName} = {}`
+      return `const ${$layerName} = {}`
+    })
+
+    return [...vars].join('\n')
+  }
+
+  private getLayer(path: string) {
+    const name = basename(path)
+    const layer = name.split('.').slice(1, -1).sort().join('.')
+    if (layer) return layer
+    return this.options.default ?? ''
+  }
+
+  private getLayerName(layer: string, style: '$camel' | '$Pascal') {
+    const LayerName = layer.split('.').map(this.capitalize).join('')
+    if (style === '$camel') return `$${this.decapitalize(LayerName)}`
+    if (style === '$Pascal') return `$${LayerName}`
+    throw this.never
+  }
+
+  private capitalize(string: string) {
+    return string.charAt(0).toUpperCase() + string.slice(1)
+  }
+
+  private decapitalize(string: string) {
+    return string.charAt(0).toLowerCase() + string.slice(1)
+  }
+
+  private isTopLayer(layer: string) {
+    return !layer.includes('.')
+  }
+
+  private async write(path: string, content: string) {
+    const [prevContent] = await safe(() => readFile(path, 'utf-8'))
+    if (content === prevContent) return
+    await writeFile(path, content, 'utf-8')
+  }
+}

package/bin.js

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-import './dist/bin.js'

package/dist/bin.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/bin.js

@@ -1,25 +0,0 @@
-import minimist from 'minimist';
-import { paralayer } from './index.js';
-const argv = minimist(process.argv.slice(2), {
-    string: ['default'],
-    boolean: ['watch', 'globalize'],
-    default: { watch: false, default: null, globalize: false },
-});
-const paths = argv._;
-const input = paths.slice(0, -1);
-const output = paths.at(-1);
-if (input.length === 0) {
-    console.error('[paralayer] Input directory is not provided');
-    process.exit(1);
-}
-if (!output) {
-    console.error('[paralayer] Output directory is not provided');
-    process.exit(1);
-}
-await paralayer({
-    input: input,
-    output: output,
-    watch: argv.watch,
-    default: argv.default,
-    globalize: argv.globalize,
-});

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-import { type Options } from './paralayer.js';
-export declare function paralayer(options: Options): Promise<string>;
-export default paralayer;

package/dist/index.js

@@ -1,7 +0,0 @@
-import { Paralayer } from './paralayer.js';
-export async function paralayer(options) {
-    const pl = new Paralayer(options);
-    await pl.start();
-    return await pl.readSetupJs();
-}
-export default paralayer;

package/dist/paralayer.d.ts

@@ -1,42 +0,0 @@
-import * as $utils from '@eposlabs/utils';
-export type DirPath = string;
-export type File = {
-    content: string;
-    names: string[];
-};
-export type Options = {
-    input: DirPath | DirPath[];
-    output: DirPath;
-    watch?: boolean;
-    /** Default layer name. If a file name does not have layer tags, default name will be used. */
-    default?: string | null;
-    /** Whether the layer variables should be exposed globally. */
-    globalize?: boolean;
-};
-export declare class Paralayer extends $utils.Unit {
-    private files;
-    private options;
-    private started;
-    private ready;
-    private ready$;
-    private queue;
-    private extensions;
-    private previousLayers;
-    private watcher;
-    constructor(options: Options);
-    start: () => Promise<void>;
-    readSetupJs(): Promise<string>;
-    private onAll;
-    private onReady;
-    private build;
-    private extractExportedClassNames;
-    private generateLayerContent;
-    private generateIndexContent;
-    private generateSetupContent;
-    private getLayer;
-    private getLayerName;
-    private capitalize;
-    private decapitalize;
-    private isTopLayer;
-    private write;
-}

package/dist/paralayer.js

@@ -1,220 +0,0 @@
-import * as $chokidar from 'chokidar';
-import * as $fs from 'node:fs/promises';
-import * as $path from 'node:path';
-import * as $utils from '@eposlabs/utils';
-export class Paralayer extends $utils.Unit {
-    files = {};
-    options;
-    started = false;
-    ready = false;
-    ready$ = Promise.withResolvers();
-    queue = new $utils.Queue();
-    extensions = new Set(['.ts', '.tsx', '.js', '.jsx']);
-    previousLayers = [];
-    watcher = null;
-    constructor(options) {
-        super();
-        this.options = options;
-    }
-    start = async () => {
-        if (this.started)
-            return;
-        this.started = true;
-        await $utils.safe($fs.rm(this.options.output, { recursive: true }));
-        this.watcher = $chokidar.watch(this.options.input);
-        this.watcher.on('all', this.onAll);
-        this.watcher.on('ready', this.onReady);
-        await this.ready$.promise;
-        await this.queue.run(() => this.build());
-        if (!this.options.watch)
-            await this.watcher.close();
-    };
-    async readSetupJs() {
-        const setupJsPath = $path.join(this.options.output, 'setup.js');
-        return await $fs.readFile(setupJsPath, 'utf-8');
-    }
-    // ---------------------------------------------------------------------------
-    // HANDLERS
-    // ---------------------------------------------------------------------------
-    onAll = async (event, path) => {
-        // Process only file events
-        if (!['add', 'change', 'unlink'].includes(event))
-            return;
-        // Not supported file extension? -> Ignore
-        const ext = $path.extname(path);
-        if (!this.extensions.has(ext))
-            return;
-        // No layer in the file name? -> Ignore
-        if (!this.getLayer(path))
-            return;
-        // Initial scan? -> Just register file
-        if (!this.ready) {
-            this.files[path] = null;
-            return;
-        }
-        // File removed? -> Remove and rebuild
-        if (event === 'unlink') {
-            delete this.files[path];
-            await this.queue.run(() => this.build());
-        }
-        // File added/changed? -> Reset its content and rebuild
-        if (event === 'add' || event === 'change') {
-            this.files[path] = null;
-            await this.queue.run(() => this.build());
-        }
-    };
-    onReady = async () => {
-        this.ready = true;
-        this.ready$.resolve();
-    };
-    // ---------------------------------------------------------------------------
-    // BUILD
-    // ---------------------------------------------------------------------------
-    async build() {
-        // Group file paths by layers
-        const paths = Object.keys(this.files);
-        if (paths.length === 0)
-            return;
-        const pathsByLayers = Object.groupBy(paths, path => this.getLayer(path));
-        const allLayers = Object.keys(pathsByLayers);
-        // Ensure output directory exists
-        await $fs.mkdir(this.options.output, { recursive: true });
-        // Ensure all files are read
-        await Promise.all(paths.map(async (path) => {
-            if (this.files[path])
-                return;
-            const content = await $fs.readFile(path, 'utf-8');
-            const names = this.extractExportedClassNames(content);
-            this.files[path] = { content, names };
-        }));
-        // Create layer files
-        for (const layer in pathsByLayers) {
-            // Generate layer.[layer].ts
-            const layerFile = $path.join(this.options.output, `layer.${layer}.ts`);
-            const layerPaths = pathsByLayers[layer].toSorted();
-            const layerContent = this.generateLayerContent(layer, layerPaths);
-            await this.write(layerFile, layerContent);
-            // Top layer? -> Generate index.[layer].ts
-            if (this.isTopLayer(layer)) {
-                const indexFile = $path.join(this.options.output, `index.${layer}.ts`);
-                const indexContent = this.generateIndexContent(layer, allLayers);
-                await this.write(indexFile, indexContent);
-            }
-        }
-        // Determine removed layers
-        const removedLayers = this.previousLayers.filter(l => !allLayers.includes(l));
-        this.previousLayers = allLayers;
-        // Delete files of removed layers
-        for (const layer of removedLayers) {
-            // Delete layer file
-            const layerFile = $path.join(this.options.output, `layer.${layer}.ts`);
-            await $fs.rm(layerFile);
-            // Top layer? -> Remove index file
-            if (this.isTopLayer(layer)) {
-                const indexFile = $path.join(this.options.output, `index.${layer}.ts`);
-                await $fs.rm(indexFile);
-            }
-        }
-        // Generate setup.js file
-        const setupFile = $path.join(this.options.output, 'setup.js');
-        const setupContent = this.generateSetupContent(allLayers);
-        await this.write(setupFile, setupContent);
-    }
-    // ---------------------------------------------------------------------------
-    // HELPERS
-    // ---------------------------------------------------------------------------
-    extractExportedClassNames(content) {
-        return content
-            .split('export class ')
-            .slice(1)
-            .map(part => part.split(' ')[0].split('<')[0]);
-    }
-    generateLayerContent(layer, layerPaths) {
-        const $LayerName = this.getLayerName(layer, '$Pascal');
-        const $layerName = this.getLayerName(layer, '$camel');
-        const allNames = layerPaths.flatMap(path => this.files[path]?.names ?? []);
-        const imports = layerPaths
-            .map(path => {
-            const file = this.files[path];
-            if (!file)
-                return '';
-            if (file.names.length === 0)
-                return '';
-            const names = file.names;
-            const types = file.names.map(name => `type ${name} as ${name}Type`);
-            const relativePath = $path.relative(this.options.output, path);
-            return `import { ${[...names, ...types].join(', ')} } from '${relativePath}'`;
-        })
-            .filter(Boolean);
-        const assign = [`Object.assign(${$layerName}, {`, ...allNames.map(name => `  ${name},`), `})`];
-        const globals = [
-            `declare global {`,
-            `  var ${$layerName}: ${$LayerName}`,
-            ``,
-            `  interface ${$LayerName} {`,
-            ...allNames.map(name => `    ${name}: typeof ${name}`),
-            `  }`,
-            ``,
-            `  namespace ${$layerName} {`,
-            ...allNames.map(name => `    export type ${name} = ${name}Type`),
-            `  }`,
-            `}`,
-        ];
-        return [...imports, '', ...assign, '', ...globals, ''].join('\n');
-    }
-    generateIndexContent(topLayer, allLayers) {
-        const imports = allLayers
-            .filter(layer => layer.includes(topLayer))
-            .sort((layer1, layer2) => {
-            if (layer1.length !== layer2.length)
-                return layer2.length - layer1.length;
-            return layer1.localeCompare(layer2);
-        })
-            .map(layer => `import './layer.${layer}.ts'`);
-        return [...imports].join('\n');
-    }
-    generateSetupContent(allLayers) {
-        const layers = allLayers.toSorted((layer1, layer2) => {
-            if (layer1.length !== layer2.length)
-                return layer1.length - layer2.length;
-            return layer1.localeCompare(layer2);
-        });
-        const vars = layers.map(layer => {
-            const $layerName = this.getLayerName(layer, '$camel');
-            if (this.options.globalize)
-                return `globalThis.${$layerName} = {}`;
-            return `const ${$layerName} = {}`;
-        });
-        return [...vars].join('\n');
-    }
-    getLayer(path) {
-        const name = $path.basename(path);
-        const layer = name.split('.').slice(1, -1).sort().join('.');
-        if (layer)
-            return layer;
-        return this.options.default ?? '';
-    }
-    getLayerName(layer, style) {
-        const LayerName = layer.split('.').map(this.capitalize).join('');
-        if (style === '$camel')
-            return `$${this.decapitalize(LayerName)}`;
-        if (style === '$Pascal')
-            return `$${LayerName}`;
-        throw this.never;
-    }
-    capitalize(string) {
-        return string.charAt(0).toUpperCase() + string.slice(1);
-    }
-    decapitalize(string) {
-        return string.charAt(0).toLowerCase() + string.slice(1);
-    }
-    isTopLayer(layer) {
-        return !layer.includes('.');
-    }
-    async write(path, content) {
-        const [prevContent] = await $utils.safe(() => $fs.readFile(path, 'utf-8'));
-        if (content === prevContent)
-            return;
-        await $fs.writeFile(path, content, 'utf-8');
-    }
-}