paralayer 1.0.6 → 1.1.1

package/dist/bin.d.ts

@@ -1 +1 @@
-export {};
+#!/usr/bin/env node

package/dist/bin.js

@@ -1,25 +1,30 @@
-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 },
+#!/usr/bin/env node
+import {
+  paralayer
+} from "./chunk-BES3GT56.js";
+
+// src/bin.ts
+import minimist from "minimist";
+var argv = minimist(process.argv.slice(2), {
+  string: ["defaultLayerName"],
+  boolean: ["watch", "globalize"],
+  default: { watch: false, globalize: false, defaultLayerName: null }
 });
-const paths = argv._;
-const input = paths.slice(0, -1);
-const output = paths.at(-1);
+var paths = argv._;
+var input = paths.slice(0, -1);
+var output = paths.at(-1);
 if (input.length === 0) {
-    console.error('[paralayer] Input directory is not provided');
-    process.exit(1);
+  console.error("[paralayer] Input directory is not provided");
+  process.exit(1);
 }
 if (!output) {
-    console.error('[paralayer] Output directory is not provided');
-    process.exit(1);
+  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,
+  input,
+  output,
+  watch: argv.watch,
+  globalize: argv.globalize,
+  defaultLayerName: argv.defaultLayerName
 });

package/dist/chunk-BES3GT56.js

@@ -0,0 +1,195 @@
+// src/paralayer.ts
+import { Queue, safe, Unit } from "@eposlabs/utils";
+import { watch } from "chokidar";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { basename, extname, join, relative } from "path";
+var Paralayer = class extends Unit {
+  files = {};
+  options;
+  started = false;
+  ready = false;
+  ready$ = Promise.withResolvers();
+  queue = new Queue();
+  extensions = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+  previousLayers = [];
+  watcher = null;
+  constructor(options) {
+    super();
+    this.options = options;
+  }
+  async start() {
+    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
+  // ---------------------------------------------------------------------------
+  onAll = async (event, path) => {
+    if (!["add", "change", "unlink"].includes(event)) return;
+    const ext = extname(path);
+    if (!this.extensions.has(ext)) return;
+    if (!this.getLayer(path)) return;
+    if (!this.ready) {
+      this.files[path] = null;
+      return;
+    }
+    if (event === "unlink") {
+      delete this.files[path];
+      await this.queue.run(() => this.build());
+    }
+    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() {
+    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);
+    await mkdir(this.options.output, { recursive: true });
+    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 };
+      })
+    );
+    for (const layer in pathsByLayers) {
+      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);
+      if (this.isTopLayer(layer)) {
+        const indexFile = join(this.options.output, `index.${layer}.ts`);
+        const indexContent = this.generateIndexContent(layer, allLayers);
+        await this.write(indexFile, indexContent);
+      }
+    }
+    const removedLayers = this.previousLayers.filter((l) => !allLayers.includes(l));
+    this.previousLayers = allLayers;
+    for (const layer of removedLayers) {
+      const layerFile = join(this.options.output, `layer.${layer}.ts`);
+      await rm(layerFile);
+      if (this.isTopLayer(layer)) {
+        const indexFile = join(this.options.output, `index.${layer}.ts`);
+        await rm(indexFile);
+      }
+    }
+    const setupFile = join(this.options.output, "setup.js");
+    const setupContent = this.generateSetupContent(allLayers);
+    await this.write(setupFile, setupContent);
+  }
+  // ---------------------------------------------------------------------------
+  // HELPERS
+  // ---------------------------------------------------------------------------
+  extractExportedClassNames(content) {
+    if (content.includes("paralayer-ignore")) return [];
+    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 = 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 = basename(path);
+    const layer = name.split(".").slice(1, -1).sort().join(".");
+    if (layer) return layer;
+    return this.options.defaultLayerName ?? "";
+  }
+  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 safe(() => readFile(path, "utf-8"));
+    if (content === prevContent) return;
+    await writeFile(path, content, "utf-8");
+  }
+};
+async function paralayer(options) {
+  const pl = new Paralayer(options);
+  await pl.start();
+  return await pl.readSetupJs();
+}
+var paralayer_default = paralayer;
+
+export {
+  Paralayer,
+  paralayer,
+  paralayer_default
+};

package/dist/paralayer.d.ts

@@ -1,19 +1,20 @@
-import * as $utils from '@eposlabs/utils';
-export type DirPath = string;
-export type File = {
+import { Unit } from '@eposlabs/utils';
+
+type DirPath = string;
+type File = {
     content: string;
     names: string[];
 };
-export type Options = {
+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;
+    /** If a file name does not have layer tags, default layer name will be used. */
+    defaultLayerName?: string | null;
 };
-export declare class Paralayer extends $utils.Unit {
+declare class Paralayer extends Unit {
     private files;
     private options;
     private started;
@@ -24,7 +25,7 @@ export declare class Paralayer extends $utils.Unit {
     private previousLayers;
     private watcher;
     constructor(options: Options);
-    start: () => Promise<void>;
+    start(): Promise<void>;
     readSetupJs(): Promise<string>;
     private onAll;
     private onReady;
@@ -40,3 +41,6 @@ export declare class Paralayer extends $utils.Unit {
     private isTopLayer;
     private write;
 }
+declare function paralayer(options: Options): Promise<string>;
+
+export { type DirPath, type File, type Options, Paralayer, paralayer as default, paralayer };

package/dist/paralayer.js

@@ -1,222 +1,10 @@
-import * as $utils from '@eposlabs/utils';
-import * as $chokidar from 'chokidar';
-import * as $fs from 'node:fs/promises';
-import * as $path from 'node:path';
-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) {
-        if (content.includes('paralayer-ignore'))
-            return [];
-        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');
-    }
-}
+import {
+  Paralayer,
+  paralayer,
+  paralayer_default
+} from "./chunk-BES3GT56.js";
+export {
+  Paralayer,
+  paralayer_default as default,
+  paralayer
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paralayer",
-  "version": "1.0.6",
+  "version": "1.1.1",
   "type": "module",
   "license": "MIT",
   "author": "imkost",
@@ -10,26 +10,27 @@
     "vite-plugin"
   ],
   "scripts": {
-    "dev": "rm -rf dist && tsc --watch",
-    "build": "rm -rf dist && tsc",
+    "build": "tsup src --format esm --dts --clean",
     "lint": "tsc --noEmit",
     "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": "./dist/paralayer.js"
+    },
+    "./ts": {
+      "import": "./src/paralayer.ts"
     }
   },
   "files": [
-    "dist",
-    "bin.js"
+    "src",
+    "dist"
   ],
   "dependencies": {
-    "@eposlabs/utils": "^1.0.0",
+    "@eposlabs/utils": "^1.1.1",
     "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 './paralayer.ts'
+
+const argv = minimist(process.argv.slice(2), {
+  string: ['defaultLayerName'],
+  boolean: ['watch', 'globalize'],
+  default: { watch: false, globalize: false, defaultLayerName: null },
+})
+
+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,
+  globalize: argv.globalize,
+  defaultLayerName: argv.defaultLayerName,
+})

package/src/paralayer.ts

@@ -0,0 +1,276 @@
+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
+  /** Whether the layer variables should be exposed globally. */
+  globalize?: boolean
+  /** If a file name does not have layer tags, default layer name will be used. */
+  defaultLayerName?: string | null
+}
+
+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
+  }
+
+  async start() {
+    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.defaultLayerName ?? ''
+  }
+
+  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')
+  }
+}
+
+export async function paralayer(options: Options) {
+  const pl = new Paralayer(options)
+  await pl.start()
+  return await pl.readSetupJs()
+}
+
+export default paralayer

package/bin.js

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

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;