paralayer 1.3.0 → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "paralayer",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "type": "module",
   "license": "MIT",
   "author": "imkost",
@@ -10,26 +10,20 @@
     "vite-plugin"
   ],
   "scripts": {
-    "build": "tsup src --format esm --dts --clean --no-splitting",
     "lint": "tsc --noEmit",
-    "release": "sh -c 'npm version ${1:-minor} && npm run build && npm publish' --"
+    "release": "sh -c 'npm version ${1:-minor} && npm publish' --"
   },
   "bin": {
-    "paralayer": "./dist/bin.js",
-    "paralayer-ts": "./src/bin.ts"
+    "paralayer": "./src/bin.ts"
   },
   "exports": {
-    ".": {
-      "source": "./src/paralayer.ts",
-      "import": "./dist/paralayer.js"
-    }
+    ".": "./src/paralayer.ts"
   },
   "files": [
-    "src",
-    "dist"
+    "src"
   ],
   "dependencies": {
-    "@eposlabs/utils": "^1.2.2",
+    "@eposlabs/utils": "^1.5.0",
     "chokidar": "^4.0.3",
     "minimist": "^1.2.8"
   },

package/src/paralayer.ts

@@ -204,7 +204,7 @@ export class Paralayer extends Unit {
       `}`,
     ]
 
-    return [...imports, '', ...assign, '', ...globals, ''].join('\n')
+    return ['// @ts-ignore', '', ...imports, '', ...assign, '', ...globals, ''].join('\n')
   }
 
   private generateIndexContent(topLayer: string, allLayers: string[]) {

package/dist/bin.d.ts

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

package/dist/bin.js

@@ -1,218 +0,0 @@
-#!/usr/bin/env node
-
-// src/bin.ts
-import minimist from "minimist";
-
-// 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 paths2 = Object.keys(this.files);
-    if (paths2.length === 0) return;
-    const pathsByLayers = Object.groupBy(paths2, (path) => this.getLayer(path));
-    const allLayers = Object.keys(pathsByLayers);
-    await mkdir(this.options.output, { recursive: true });
-    await Promise.all(
-      paths2.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();
-}
-
-// src/bin.ts
-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/paralayer.d.ts

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

@@ -1,194 +0,0 @@
-// 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_default as default,
-  paralayer
-};