@cmmn/tools 2.2.3 → 3.0.0-alpha-4

package/dist/typings/commands/index.d.ts

@@ -0,0 +1,10 @@
+export { compile } from "./compile.ts";
+export { typings } from "./typings.ts";
+export { gen } from "./gen.js";
+export { bundle } from "./bundle.ts";
+export { dev } from "./dev.ts";
+export { publish } from "./publish.ts";
+export { format } from "./format.js";
+export { lint } from "./lint.js";
+export { version } from "./version.js";
+export { host } from "./host.js";

package/dist/typings/commands/lint.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param flags {import("../model/flags.ts").Flags}
+ * @returns {Promise<import('@swc/types').Config>}
+ */
+export function lint(flags: import("../model/flags.ts").Flags): Promise<import("@swc/types").Config>;

package/dist/typings/commands/nginx.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param flags {import("../model/flags.ts").Flags}
+ * @returns {Promise<void>}
+ */
+export function nginx(flags: import("../model/flags.ts").Flags): Promise<void>;
+export function nginxTemplate(path: any, host: any, port: any, proxy: any): string;

package/dist/typings/commands/publish.d.ts

@@ -0,0 +1,2 @@
+import { Flags } from "../model/flags";
+export declare function publish(flags: Flags): Promise<void>;

package/dist/typings/commands/typings.d.ts

@@ -0,0 +1,4 @@
+import { Flags } from "../model/flags";
+import { Target } from "../model/target";
+export declare function typings(flags: Flags): Promise<void>;
+export declare function generateTypings(target: Target): void;

package/dist/typings/commands/version.d.ts

@@ -0,0 +1 @@
+export function version(flags: any): Promise<void>;

package/dist/typings/helpers/fastify-compress.d.ts

@@ -0,0 +1,6 @@
+import { FastifyInstance } from "fastify";
+export declare function fastifyCompress(app: FastifyInstance, options?: FastifyCompressOptions): void;
+export type FastifyCompressOptions = {
+    encodings: FastifyCompressEncoding[];
+};
+export type FastifyCompressEncoding = 'br' | 'zstd' | 'gzip' | 'deflate';

package/dist/typings/helpers/getTSConfig.d.ts

@@ -0,0 +1,11 @@
+import { CompilerOptions } from "typescript";
+export declare function getTSConfig(configPath: string): any;
+export type TypescriptConfig = {
+    extends?: string;
+    compilerOptions?: CompilerOptions;
+    exclude?: string[];
+    include?: string[];
+    references?: Array<{
+        path: string;
+    }>;
+};

package/dist/typings/helpers/terminal.d.ts

@@ -0,0 +1,22 @@
+export class Terminal {
+    constructor(flags: any, targets: any);
+    term: any;
+    /**
+     * @type {import("../model/flags.ts").Flags}
+     */
+    flags: import("../model/flags.ts").Flags;
+    /**
+     * @type {import("../model/target.js").Target[]}
+     */
+    targets: import("../model/target.js").Target[];
+    headers: string[];
+    startTime: number;
+    data: {};
+    setData(target: any, data: any): void;
+    renderInfo(): void;
+    renderTable(): void;
+    fit(data: any): any;
+    getTime(time: any): string;
+    getSize(size: any): string;
+    [Symbol.dispose](): void;
+}

package/dist/typings/helpers/watcher.d.ts

@@ -0,0 +1,7 @@
+import { Target } from "../model/target";
+export declare class Watcher {
+    abort: AbortController;
+    constructor();
+    watchTarget(target: Target): Promise<void>;
+    [Symbol.dispose](): void;
+}

package/dist/typings/index.d.ts

@@ -0,0 +1,4 @@
+import { Monorepo } from "./model/monorepo";
+import type { BundleJson, Asset } from "./model/bundle";
+import { Flags } from "./model/flags";
+export { Monorepo, Flags, type BundleJson, type Asset };

package/dist/typings/model/bundle.d.ts

@@ -0,0 +1,34 @@
+import { Entry, Pack } from "./pack";
+export declare class Bundle {
+    private pack;
+    private output;
+    constructor(pack: Pack, output: Output[]);
+    fileNames(): string[];
+    get(id: string): string | Uint8Array<ArrayBufferLike>;
+    getPublicAsset(id: string): Promise<Buffer<ArrayBufferLike>>;
+    getBundleJson(): Promise<BundleJson>;
+    private getOutputAsset;
+    private getDeps;
+}
+export declare function getHash(data: string | Uint8Array): Promise<string>;
+export type Output = {
+    entry?: Entry;
+    fileName: string;
+    data: string | Uint8Array;
+    deps: Array<{
+        pack: Pack;
+        path: string;
+    }>;
+};
+export type BundleJson = {
+    baseURI: string;
+    assets: Asset[];
+};
+export type Asset = {
+    path: string;
+    regex?: string;
+    hash: string;
+    size: number;
+    optional?: boolean;
+    deps: Record<string, string[]>;
+};

package/dist/typings/model/flags.d.ts

@@ -0,0 +1,15 @@
+export declare class Flags {
+    args?: string[];
+    static Current: Flags;
+    watch?: boolean;
+    minify?: boolean;
+    workspace?: string;
+    unsafe?: boolean;
+    version?: string;
+    command?: string;
+    production?: boolean;
+    deploy?: boolean;
+    out: string;
+    constructor(args?: string[]);
+    get(arg: any): string;
+}

package/dist/typings/model/monorepo.d.ts

@@ -0,0 +1,18 @@
+import { Pack } from "./pack";
+import { Target } from "./target";
+import { Resolver } from "./resolver";
+import { Flags } from "./flags";
+import { ViteBundler } from "../bundlers/vite.bundler";
+import { RolldownBundler } from "../bundlers/rolldown-bundler";
+export declare class Monorepo {
+    readonly root: Target;
+    private readonly packsMap;
+    readonly flags: Flags;
+    static load(flags?: Flags, rootDir?: string): Promise<Monorepo>;
+    readonly packs: Pack[];
+    private constructor();
+    get targets(): Target[];
+    get(id: string): Pack;
+    readonly resolver: Resolver;
+    createBundler(pack: Pack): ViteBundler | RolldownBundler;
+}

package/dist/typings/model/pack.d.ts

@@ -0,0 +1,45 @@
+import { JSONSchemaForNPMPackageJsonFiles } from "@schemastore/package";
+import { Flags } from "./flags";
+export declare class Pack extends EventTarget {
+    readonly rootDir: any;
+    readonly packageJson: JSONSchemaForNPMPackageJsonFiles;
+    static read(id: string, version?: string, dir?: string): Promise<Pack>;
+    getAllDependencies(prod: boolean): Generator<[string, string], void, unknown>;
+    deps: Pack[];
+    reactions: Pack[];
+    constructor(rootDir: any, packageJson: JSONSchemaForNPMPackageJsonFiles);
+    init(flags: Flags, packsMap: Map<string, Pack>): void;
+    get isServer(): boolean;
+    get name(): string;
+    term: any;
+    log(text: any): void;
+    error(text: any): void;
+    _entries: Entry[];
+    get entries(): Entry[];
+    /**
+     * @param name relative path inside pack: "", "/index.js", "/bundler"...
+     */
+    getEntry(name: string): Entry | undefined;
+    protected createEntry(name: string, source: string): Entry;
+    getExport(entry: string, file: string): string;
+    get publicPath(): string;
+}
+export declare class ChangeEvent extends Event {
+    payload: any;
+    from: any;
+    constructor(payload: any, from: any);
+}
+export declare class FileChangeEvent extends Event {
+    files: string[];
+    constructor(files: string[]);
+}
+export type Entry = {
+    name: string;
+    source: string;
+    relative: string;
+    isHTML: boolean;
+    isExcluded: boolean;
+    output: string;
+    isTypeScript: boolean;
+    isJavaScript: boolean;
+};

package/dist/typings/model/resolver.d.ts

@@ -0,0 +1,38 @@
+import { Pack } from "./pack";
+import { Flags } from "./flags";
+export declare class Resolver {
+    private readonly packs;
+    private flags;
+    basePath: string;
+    constructor(packs: Pack[], flags: Flags);
+    /**
+     * Resolve id to absolute path
+     * @param id - relative path: "react", "react/jsx-runtime.js", "loro-crdt/bundler", "loro-crdt/loro.wasm"...
+     * @param importer
+     * @param options
+     */
+    resolveId: (id: string, importer?: string, options?: any) => {
+        external: boolean | "absolute" | "relative";
+        id: string;
+        path: string;
+        entry: import("./pack").Entry;
+        pack: Pack;
+    };
+    resolvePath(path: string, importer?: string, options?: any): {
+        pack: Pack;
+        path: string;
+    };
+    private resolveWithProxy;
+    resolveInPack(pack: Pack, id: string, importer?: string, options?: any): {
+        external: boolean | "absolute" | "relative";
+        id: string;
+        path: string;
+        entry: import("./pack").Entry;
+        pack: Pack;
+    };
+    getPackNames(): string[];
+    getPack(id: string): {
+        pack: Pack;
+        path: string;
+    } | undefined;
+}

package/dist/typings/model/target.d.ts

@@ -0,0 +1,27 @@
+import { TypescriptConfig } from "../helpers/getTSConfig.js";
+import { Config } from "@swc/core";
+import { Entry, Pack } from "./pack";
+export declare class Target extends Pack {
+    readonly publicDir: string;
+    get publicPath(): string | undefined;
+    _tsConfig: TypescriptConfig;
+    get tsConfig(): TypescriptConfig;
+    isExcluded(fileName: string, isRelative?: boolean): boolean;
+    get swcConfigPath(): string;
+    swcConfigBase: any;
+    _swcConfig: Config;
+    get swcConfig(): Config;
+    getPublishPackageJson(): Promise<string>;
+    protected createEntry(name: string, source: string): Entry;
+    get https(): {
+        host: unknown;
+        port: unknown;
+        cert: string;
+        key: string;
+    };
+    _proxy: any;
+    get proxy(): Array<{
+        regex: RegExp;
+        replace: any;
+    }>;
+}

package/dist/typings/servers/bundle-server.d.ts

@@ -0,0 +1,10 @@
+import { FastifyReply, FastifyRequest } from "fastify";
+import { PackServer } from "./pack-server";
+import { IBundler } from "../bundlers/types";
+import { Pack } from "../model/pack";
+export declare class BundleServer extends PackServer {
+    private bundler;
+    constructor(pack: Pack, bundler: IBundler);
+    private bundleRequest;
+    protected handle(request: FastifyRequest, reply: FastifyReply): Promise<string | Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike>>;
+}

package/dist/typings/servers/dev-server.d.ts

@@ -0,0 +1,16 @@
+import { Target } from "../model/target";
+import { FastifyInstance, FastifyRequest } from "fastify";
+import { Monorepo } from "../model/monorepo";
+import { Pack } from "../model/pack";
+import { PackServer } from "./pack-server";
+export declare class DevServer {
+    private monorepo;
+    rootTarget: Target;
+    targetServers: Map<Pack, PackServer>;
+    get resolver(): import("../model/resolver").Resolver;
+    private createServer;
+    get isBundler(): boolean;
+    constructor(monorepo: Monorepo);
+    rewriteUrl: (req: FastifyRequest) => string;
+    register(app: FastifyInstance): Promise<void>;
+}

package/dist/typings/servers/pack-server.d.ts

@@ -0,0 +1,9 @@
+import { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
+import { Pack } from "../model/pack";
+export declare abstract class PackServer {
+    protected pack: Pack;
+    constructor(pack: Pack);
+    protected abstract handle(req: FastifyRequest, reply: FastifyReply): Promise<unknown>;
+    register(app: FastifyInstance): Promise<void>;
+    getMimeType(path: string): any;
+}

package/dist/typings/servers/target-runnner.d.ts

@@ -0,0 +1,13 @@
+import { Watcher } from "../helpers/watcher.js";
+import { PackServer } from "./pack-server";
+import { FastifyInstance, FastifyReply, FastifyRequest } from "fastify";
+export declare class TargetRunner extends PackServer {
+    static port: number;
+    port: number;
+    /** @type {Promise<import('node:child_process').ChildProcess> | undefined} **/
+    cp: any;
+    watcher: Watcher;
+    protected handle(req: FastifyRequest, reply: FastifyReply): Promise<unknown>;
+    register(app: FastifyInstance): Promise<void>;
+    runServer(): Promise<any>;
+}

package/dist/typings/servers/vite-dev-server.d.ts

@@ -0,0 +1,18 @@
+import { Target } from "../model/target";
+import { FastifyReply, FastifyRequest } from "fastify";
+import { PackServer } from "./pack-server";
+import { Monorepo } from "../model/monorepo";
+export declare class ViteDevelopmentServer extends PackServer {
+    private target;
+    private monorepo;
+    readonly wsPrefix = "/@ws";
+    private viteBuilder;
+    constructor(target: Target, monorepo: Monorepo);
+    protected handle(request: FastifyRequest, reply: FastifyReply): Promise<string | Uint8Array<ArrayBufferLike>>;
+    private devServerRequest;
+    private createServer;
+    /**
+     * Emit event on ws and proxies events from dependent dev-servers
+     */
+    private enhanceWebSocket;
+}

package/dist/typings/specs/dev-server.specs.d.ts

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

package/dist/typings/specs/monorepo.specs.d.ts

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

package/dist/typings/specs/resolver.specs.d.ts

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

package/dist/typings/specs/rolldown.specs.d.ts

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

package/dist/typings/specs/target-specs.d.ts

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

package/dist/typings/specs/vite-bundler.specs.d.ts

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

package/dist/typings/test/test.d.ts

@@ -0,0 +1,16 @@
+import * as t from "node:test";
+import * as assert from "node:assert";
+import { expect } from "expect";
+declare function _suite<TClass extends new (ctx: t.SuiteContext) => (BaseTest | unknown)>(target: TClass, context: ClassDecoratorContext<TClass>): void;
+declare function _test<TClass, TValue extends (this: TClass) => unknown>(method: TValue, context: ClassMethodDecoratorContext<TClass, TValue>): void;
+export declare const test: ((() => typeof _test) & typeof _test);
+export declare const suite: ((() => typeof _suite) & typeof _suite);
+export declare const describe: (() => typeof _suite) & typeof _suite;
+export { assert, expect };
+export { mock, type SuiteContext, type TestContext } from "node:test";
+export type BaseTest = {
+    after?(ctx: t.SuiteContext): unknown;
+    before?(ctx: t.SuiteContext): unknown;
+    afterEach?(ctx: t.TestContext): unknown;
+    beforeEach?(ctx: t.TestContext): unknown;
+};

package/{compile → helpers}/tsconfig.json

@@ -3,32 +3,35 @@
     "module": "esnext",
     "moduleResolution": "bundler",
     "target": "ESNext",
-    "composite": true,
+    "composite": false,
     "sourceMap": false,
     "baseUrl": "./",
-    "experimentalDecorators": true,
+    "experimentalDecorators": false,
     "checkJs": false,
-    "outDir": "./dist/esm",
     "skipLibCheck": true,
     "incremental": true,
     "disableSolutionSearching": true,
     "assumeChangesOnlyAffectDirectDependencies": true,
     "skipDefaultLibCheck": true,
+    "isolatedModules": true,
     "allowJs": true,
     "disableReferencedProjectLoad": true,
     "disableSourceOfProjectReferenceRedirect": true,
     "allowSyntheticDefaultImports": true,
-    "emitDecoratorMetadata": true,
+    "emitDeclarationOnly": true,
+    "declaration": false,
     "noEmitHelpers": true,
-    "declarationDir": "./dist/typings",
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
     "useDefineForClassFields": false,
-    "declaration": true,
+    "stripInternal": true,
     "lib": [
-      "ES2020.BigInt",
-      "ESNext",
-      "DOM"
+      "ES2024",
+      "WebWorker"
+    ],
+    "types": [
+      "vite/client",
+      "node"
     ]
   },
   "exclude": [

package/node/hooks-dev.js

@@ -0,0 +1,72 @@
+import {Target} from "../dist/esm/helpers/target";
+import {Flags} from "../dist/esm/helpers/flags";
+import {join} from "node:path";
+import {pathToFileURL} from "node:url";
+
+const targets = await Target.readTargets(process.cwd(), new Flags(''));
+const serverUrl = 'http://127.0.0.1:9000';
+const base = '/_/';
+
+export async function resolve(specifier, context, nextResolve) {
+    if (specifier.startsWith('https://')) {
+        if (specifier.startsWith(serverUrl.replace('http://', 'https://'))){
+            specifier = specifier.replace('https://', 'http://')
+        }
+
+        for (let target of targets) {
+            if (specifier.startsWith('https://' + target.https?.host)) {
+                specifier = serverUrl + specifier.substring(('https://' + target.https?.host).length);
+                console.log('HOST:', specifier, target.https.host);
+            }
+        }
+    }
+    context.parentURL = urlToFile(context.parentURL);
+    if (specifier.startsWith(serverUrl))
+        specifier = specifier.substr(serverUrl.length);
+    if (specifier.startsWith('/_/@id/'))
+        return nextResolve(specifier.substr('/_/@id/'.length), context, nextResolve);
+    if (specifier.startsWith('/_/')) {
+        return {
+            shortCircuit: true,
+            url: serverUrl + base + specifier.substr('/_/'.length)
+        };
+    }
+    for (let target of targets) {
+        if (specifier.startsWith(target.packageJson.name)) {
+            return {
+                shortCircuit: true,
+                url: serverUrl + base + specifier
+            };
+        }
+    }
+    return nextResolve(specifier, context, nextResolve);
+}
+
+function urlToFile(url) {
+    if (!url?.startsWith(serverUrl)) return url;
+    const path = url.substr(serverUrl.length + base.length);
+    for (let target of targets) {
+        if (path.startsWith(target.packageJson.name)) {
+            const localPath = path.substr(target.packageJson.name);
+            return pathToFileURL(target.getEntry('.' + localPath) ?? join(target.rootDir, localPath));
+        }
+    }
+    if (path.startsWith('@id/'))
+        return path.substr('@id/'.length);
+}
+
+
+export async function load(url, context, defaultLoad) {
+    // For JavaScript to be loaded over the network, we need to fetch and
+    // return it.
+    if (url.startsWith(serverUrl)) {
+        return {
+            shortCircuit: true,
+            source: await fetch(url).then(x => x.text()),
+            format: 'module'
+        }
+    }
+
+    // Let Node.js handle all other URLs.
+    return defaultLoad(url, context, defaultLoad);
+}

package/node/register-dev.js

@@ -0,0 +1,3 @@
+import { register } from 'node:module';
+register('./hooks-dev.js', import.meta.url);
+import "./register.js";

package/node/register.js

@@ -0,0 +1,14 @@
+import {existsSync, linkSync, rmSync} from "node:fs";
+import path from "path";
+process.env.SWCRC = true;
+
+const from = path.resolve(import.meta.dirname, "../.swcrc");
+const to = process.cwd() + "/.swcrc";
+const exist = existsSync(to)
+if (!exist) {
+    linkSync(from, to);
+    process.addListener('beforeExit', () => rmSync(to));
+}
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+register('@swc-node/register/esm', pathToFileURL('./').toString());

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@cmmn/tools",
-  "version": "2.2.3",
+  "version": "3.0.0-alpha-4",
   "description": "Compilation, bundling, code generator, testing.",
-  "main": "dist/rollup.config.js",
   "type": "module",
   "repository": {
     "url": "https://github.com/franzzua/cmmn/tree/master/tools"
@@ -11,54 +10,66 @@
     "access": "public"
   },
   "bin": {
-    "cmmn": "bin.js"
+    "cmmn": "dist/esm/bin.js"
   },
   "exports": {
-    "./compile/tsconfig.json": "./compile/tsconfig.json",
-    "./test": "./test/index.js",
-    "./test/config": "./test/jest.config.js"
+    ".": {
+      "default": "./dist/bundle/index.js",
+      "typings": "./dist/typings/index.d.ts"
+    },
+    "./tsconfig.json": "./helpers/tsconfig.json",
+    "./import": "./node/register.js",
+    "./import-dev": "./node/register-dev.js",
+    "./test": {
+      "default": "./dist/bundle/test.js",
+      "typings": "./dist/typings/test/test.d.ts"
+    },
+    "./swcrc": "./.swcrc"
   },
-  "typesVersions": {
-    "*": {
-      "test": [
-        "./test/index.d.ts"
-      ],
-      ".": [
-        "./compile/typings.d.ts"
-      ]
-    }
+  "config": {
+    "server": true
   },
-  "typings": "compile/typings.d.ts",
   "files": [
-    "bin.js",
-    "gen/*",
-    "compile/*",
-    "bundle/*",
-    "serve/*",
-    "plugins/*",
-    "spawn/*",
-    "test/*",
-    "helpers/*"
+    "dist",
+    "node",
+    ".swcrc",
+    "tsconfig.json"
   ],
   "dependencies": {
-    "@testdeck/jest": "0.2.0",
-    "@types/node": "20.x.x",
-    "@types/sinon": "10.x.x",
+    "@biomejs/biome": "1.9.4",
+    "@fastify/caching": "9.0.3",
+    "@fastify/express": "4.0.2",
+    "@fastify/http-proxy": "11.3.0",
+    "@manypkg/get-packages": "^2.2.2",
+    "@rollup/plugin-wasm": "6.2.2",
+    "@schemastore/package": "0.0.10",
+    "@swc/core": "1.13.5",
+    "@swc/helpers": "0.5.17",
+    "@swc-node/register": "1.11.1",
+    "@types/node": "22.18.9",
+    "@yarn-tool/resolve-package": "^2.0.12",
     "@zerollup/ts-helpers": "1.7.18",
-    "earl": "^1.1.0",
-    "esbuild": "0.19.5",
-    "esbuild-plugin-less": "1.3.1",
-    "esbuild-register": "3.5.0",
-    "esbuild-visualizer": "0.4.1",
-    "fast-glob": "^3.2.11",
-    "file-uri-to-path": "2.x.x",
-    "import-meta-resolve": "2",
-    "less": "^4",
-    "live-server": "1.2.2",
-    "sinon": "17.0.1"
+    "builtin-modules": "^5.0.0",
+    "expect": "^29.7.0",
+    "fast-glob": "^3.3.3",
+    "fastify": "5.6.1",
+    "http-proxy-middleware": "3.0.5",
+    "mime-types": "2.1.35",
+    "minimatch": "10.0.3",
+    "rolldown": "1.0.0-beta.42",
+    "terminal-kit": "^3.1.2",
+    "throttle-debounce": "5.0.2",
+    "typescript": "5.8.3",
+    "unplugin": "^2.1.2",
+    "unplugin-swc": "^1.5.1",
+    "vite": "7.1.9",
+    "vite-tsconfig-paths": "^5.1.4"
   },
   "author": "",
   "license": "ISC",
   "gitHead": "2755b333808bf97f1d9454601c2a2c9a88e4a021",
-  "scripts": {}
+  "stableVersion": "3.0.0-alpha-2",
+  "peerDependencies": {
+    "@swc-node/register": "*"
+  }
 }