paralayer 0.0.2 → 0.0.4

package/bin.js

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

package/dist/bin.d.ts

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

package/dist/bin.js

@@ -0,0 +1,27 @@
+import minimist from 'minimist';
+import { Paralayer } from './paralayer.js';
+const argv = minimist(process.argv.slice(2), {
+    string: ['default'],
+    boolean: ['watch', 'globalize'],
+    default: { default: null, watch: false, 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);
+}
+const paralayer = new Paralayer({
+    input: input,
+    output: output,
+    globalize: argv.globalize,
+    default: argv.default,
+});
+await paralayer.start({
+    watch: argv.watch,
+});

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { Paralayer, type Options } from './paralayer.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { Paralayer } from './paralayer.js';

package/dist/paralayer.d.ts

@@ -0,0 +1,46 @@
+import * as $utils from '@eposlabs/utils';
+import type { Plugin } from 'vite';
+export type DirPath = string;
+export type File = {
+    content: string;
+    names: string[];
+};
+export type Options = {
+    input: DirPath | DirPath[];
+    output: DirPath;
+    /** 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;
+    private viteConfig;
+    constructor(options: Options);
+    get vite(): Plugin;
+    start: ({ watch }?: {
+        watch?: boolean | undefined;
+    }) => Promise<void>;
+    private onConfigResolved;
+    private onBuildStart;
+    private onAll;
+    private onReady;
+    private build;
+    private extractExportedClassNames;
+    private generateLayerContent;
+    private generateIndexContent;
+    private generateSetupContent;
+    private getLayer;
+    private getLayerName;
+    private capitalize;
+    private decapitalize;
+    private isTopLayer;
+}

package/dist/paralayer.js

@@ -0,0 +1,237 @@
+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;
+    viteConfig = null;
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    get vite() {
+        return {
+            name: 'paralayer',
+            enforce: 'pre',
+            configResolved: this.onConfigResolved,
+            buildStart: this.onBuildStart,
+        };
+    }
+    start = async ({ watch = false } = {}) => {
+        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 (!watch)
+            await this.watcher.close();
+    };
+    // ---------------------------------------------------------------------------
+    // VITE HOOKS
+    // ---------------------------------------------------------------------------
+    onConfigResolved = (config) => {
+        this.viteConfig = config;
+    };
+    onBuildStart = async () => {
+        if (!this.viteConfig)
+            throw this.never;
+        await this.start({ watch: !!this.viteConfig.build.watch });
+    };
+    // ---------------------------------------------------------------------------
+    // 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 $fs.writeFile(layerFile, layerContent, 'utf-8');
+            // 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 $fs.writeFile(indexFile, indexContent, 'utf-8');
+            }
+        }
+        // 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 $fs.writeFile(setupFile, setupContent, 'utf-8');
+    }
+    // ---------------------------------------------------------------------------
+    // 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)
+                throw this.never;
+            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 nocheck = '// @ts-nocheck';
+        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');
+            return `const ${$layerName} = {}`;
+        });
+        let globals = [];
+        if (this.options.globalize) {
+            globals = layers.map(layer => {
+                const $layerName = this.getLayerName(layer, '$camel');
+                return `globalThis.${$layerName} = ${$layerName}`;
+            });
+            globals.unshift('');
+        }
+        return [nocheck, '', ...vars, ...globals, ''].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('.');
+    }
+}

package/dist/vite.d.ts

@@ -0,0 +1,2 @@
+import { type Options } from './paralayer.js';
+export default function paralayer(options: Options): import("vite").Plugin<any>;

package/dist/vite.js

@@ -0,0 +1,4 @@
+import { Paralayer } from './paralayer.js';
+export default function paralayer(options) {
+    return new Paralayer(options).vite;
+}

package/package.json

@@ -1,11 +1,45 @@
 {
   "name": "paralayer",
-  "version": "0.0.2",
+  "version": "0.0.4",
+  "type": "module",
+  "license": "MIT",
+  "author": "imkost",
+  "description": "",
+  "keywords": [
+    "vite",
+    "vite-plugin"
+  ],
   "scripts": {
-    "build": "echo 'empty'",
-    "release": "npm run build && npm version patch && npm publish"
+    "dev": "rm -rf dist && tsc --watch",
+    "build": "rm -rf dist && tsc",
+    "lint": "eslint src",
+    "release": "npm version patch && npm run release:raw",
+    "release:raw": "npm run build && npm publish",
+    "release:minor": "npm version minor && npm run release:raw"
+  },
+  "bin": {
+    "paralayer": "./bin.js"
+  },
+  "exports": {
+    ".": {
+      "default": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./vite": {
+      "default": "./dist/vite.js",
+      "types": "./dist/vite.d.ts"
+    }
   },
   "files": [
-    "src"
-  ]
+    "dist",
+    "bin.js"
+  ],
+  "dependencies": {
+    "chalk": "^5.6.0",
+    "chokidar": "^4.0.3",
+    "minimist": "^1.2.8"
+  },
+  "devDependencies": {
+    "@types/minimist": "^1.2.5"
+  }
 }

package/src/paralayer.ts

@@ -1 +0,0 @@
-export class Paralayer {}