paralayer 1.1.0 → 1.1.2

package/dist/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin.js

@@ -0,0 +1,30 @@
+#!/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 }
+});
+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);
+}
+if (!output) {
+  console.error("[paralayer] Output directory is not provided");
+  process.exit(1);
+}
+await paralayer({
+  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

@@ -0,0 +1,46 @@
+import { Unit } from '@eposlabs/utils';
+
+type DirPath = string;
+type File = {
+    content: string;
+    names: string[];
+};
+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;
+};
+declare class Paralayer extends 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;
+}
+declare function paralayer(options: Options): Promise<string>;
+
+export { type DirPath, type File, type Options, Paralayer, paralayer as default, paralayer };

package/dist/paralayer.js

@@ -0,0 +1,10 @@
+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.1.0",
+  "version": "1.1.2",
   "type": "module",
   "license": "MIT",
   "author": "imkost",
@@ -10,24 +10,28 @@
     "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": "./src/bin.ts"
+    "paralayer": "./dist/bin.js",
+    "paralayer-ts": "./src/bin.ts"
   },
   "exports": {
     ".": {
-      "import": "./src/index.ts"
+      "import": "./dist/paralayer.js"
+    },
+    "./ts": {
+      "import": "./src/paralayer.ts"
     }
   },
   "files": [
-    "src"
+    "src",
+    "dist"
   ],
   "dependencies": {
-    "@eposlabs/utils": "^1.0.13",
+    "@eposlabs/utils": "^1.1.1",
     "chokidar": "^4.0.3",
     "minimist": "^1.2.8"
   },

package/src/bin.ts

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 
 import minimist from 'minimist'
-import { paralayer } from './index.ts'
+import { paralayer } from './paralayer.ts'
 
 const argv = minimist(process.argv.slice(2), {
-  string: ['default'],
+  string: ['defaultLayerName'],
   boolean: ['watch', 'globalize'],
-  default: { watch: false, default: null, globalize: false },
+  default: { watch: false, globalize: false, defaultLayerName: null },
 })
 
 const paths = argv._
@@ -27,6 +27,6 @@ await paralayer({
   input: input,
   output: output,
   watch: argv.watch,
-  default: argv.default,
   globalize: argv.globalize,
+  defaultLayerName: argv.defaultLayerName,
 })

package/src/paralayer.ts

@@ -15,10 +15,10 @@ 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
+  /** If a file name does not have layer tags, default layer name will be used. */
+  defaultLayerName?: string | null
 }
 
 export class Paralayer extends Unit {
@@ -37,7 +37,7 @@ export class Paralayer extends Unit {
     this.options = options
   }
 
-  start = async () => {
+  async start() {
     if (this.started) return
     this.started = true
 
@@ -238,7 +238,7 @@ export class Paralayer extends Unit {
     const name = basename(path)
     const layer = name.split('.').slice(1, -1).sort().join('.')
     if (layer) return layer
-    return this.options.default ?? ''
+    return this.options.defaultLayerName ?? ''
   }
 
   private getLayerName(layer: string, style: '$camel' | '$Pascal') {
@@ -266,3 +266,11 @@ export class Paralayer extends Unit {
     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/src/index.ts

@@ -1,9 +0,0 @@
-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