@cmmn/tools 2.2.3 → 3.0.0-alpha-1

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "@cmmn/tools/tsconfig.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "allowJs": true
+  },
+  "exclude": [
+    "node_modules",
+    "dist",
+    "node",
+    "helpers/tsconfig.json",
+    ".swcrc"
+  ]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Andrey
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/bin.js

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-
-import {bundle} from "./bundle/bundle.js";
-import {serve} from "./serve/serve.js";
-import {compile} from "./compile/compile.js";
-import {gen} from "./gen/gen.js";
-import {spawn} from "./spawn/index.js";
-
-const [action, ...args] = process.argv.slice(2);
-
-const actions = {
-    bundle, compile, gen, serve, spawn
-}
-
-if (action in actions) {
-    actions[action](...args);
-} else {
-    console.log(`cmmn bundle [-b] [index.ts] [--watch] [--run] [--prod]`);
-    console.log(`cmmn compile [-b] [--watch]`);
-    console.log(`cmmn gen AppRoot . [--nested]`);
-}

package/bundle/bundle.js

@@ -1,46 +0,0 @@
-import  esbuild from "esbuild";
-import {getConfigOptions} from "./getConfigs.js";
-import {ConfigCreator} from "./esbuild.config.js";
-import fs from "fs";
-import path, {relative} from "path";
-
-export async function bundle(...options) {
-    const configOptions = await getConfigOptions({
-        minify: options.includes('--minify'),
-        prod: options.includes('--prod'),
-        stats: options.includes('--stats'),
-        noSideEffects: options.includes('--no-side-effects')
-    });
-    const configs = configOptions.flatMap(x => new ConfigCreator(x).getConfig());
-    const contexts = [];
-    for (let config of configs){
-        contexts.push([config, await esbuild.context(config)]);
-    }
-
-    if (options.includes('--watch')) {
-        for (let [config, context] of contexts) {
-            await context.watch();
-        }
-        console.log('bundled. Continue watching...');
-    }else {
-        const  logs = [];
-        for (let [config, context] of contexts) {
-            const project = path.relative(process.cwd(), config.absWorkingDir);
-            const result = await context.rebuild().catch(err => {
-                err.message = project + ": " + err.message;
-                throw err;
-            });
-            const name = config.entryPoints[0].out;
-            let log = logs.find(x => x.project === project && x.name === name);
-            if (!log){
-                logs.push(log = {project, name});
-            }
-            for (let [name, value] of Object.entries(result.metafile.outputs)) {
-                if (!name.endsWith('js')) continue;
-                log[config.format+"."+config.platform] = `${(value.bytes/(2**10)).toFixed(1)} Kb`;
-            }
-            await context.dispose();
-        }
-        console.table(logs);
-    }
-}

package/bundle/esbuild.config.js

@@ -1,178 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-import { lessLoader } from 'esbuild-plugin-less';
-import {platform} from "os";
-
-/**
- * @typedef {import(rollup).RollupOptions} RollupOptions
- * @typedef {import(rollup).OutputOptions} OutputOptions
- */
-
-export class ConfigCreator {
-
-    /**
-     * @type {{
-     *     minify: boolean,
-     *     input: string,
-     *     devServer: boolean,
-     *     module: string,
-     *     external: string[],
-     *     stats: boolean,
-     *     name: string,
-     *     styles: 'modules' | null,
-     *     outDir: string,
-     *     html: string,
-     *     browser: boolean,
-     *     platform: string,
-     *     dedupe: string[],
-     *     target: string
-     *     prod: boolean,
-     *     inject: string
-     *     noSideEffects: boolean
-     * }}
-     */
-    options;
-
-    /**
-     * @type {string}
-     */
-    root = process.cwd();
-
-
-    constructor(options) {
-        this.options = {
-            module: 'es',
-            external: [],
-            name: 'index',
-            outDir: 'dist/bundle',
-            platform: 'node,browser',
-            ...options
-        };
-        if (options.rootDir)
-            this.root = options.rootDir;
-    }
-
-    get outDir() {
-        return path.join(this.root, this.options.outDir);
-    }
-
-    get importMaps(){
-        return JSON.stringify({
-            imports: Object.fromEntries(this.options.external
-                .map(key => key.replace('*', '/'))
-                .map(key => [key, `/node_modules/${this.options.alias?.[key] ?? key}`]))
-        })
-    }
-    getHtmlPlugin(){
-        if (!this.options.html)
-            return [];
-        return [
-            {
-                name: 'esbuild-html-plugin',
-                setup: (build) => { build.onEnd(async result => {
-                    if (!result.metafile)
-                        return;
-                    const injectStyles = [];
-                    const injectScripts = [
-                        `<script type="importmap">${this.importMaps}</script>`
-                    ];
-                    for (let [key, value] of Object.entries(result.metafile.outputs)){
-                        if (value.entryPoint !== this.options.input) continue;
-                        const file = path.relative(this.outDir, path.join(this.root, key));
-                        injectScripts.push(`<script type="module" src="/${file}"></script>`)
-                        if (value.cssBundle) {
-                            const file = path.relative(this.outDir, path.join(this.root, value.cssBundle));
-                            injectStyles.push(`<link rel="stylesheet" href="/${file}"></link>`)
-                        }
-                        const html = await fs.promises.readFile(path.join(this.root, this.options.html));
-                        await fs.promises.writeFile(
-                            path.join(this.outDir, 'index.html'),
-                            html.toString()
-                                .replace('</head>', `${injectStyles.map(x => `\t${x}\n`).join('')}</head>`)
-                                .replace('</body>', `${injectScripts.map(x => `\t${x}\n`).join('')}</body>`)
-                        );
-                    }
-                }); }
-            }
-        ];
-
-    }
-
-    get platforms(){
-        return this.options.platform.split(',');
-    }
-    get modules(){
-        return this.options.module.split(',');
-    }
-    getOutExtension(format, platform){
-        const ext = (this.options.minify ? '.min' : '') + ({
-            es: '.js',
-            cjs: '.cjs'
-        }[format] ?? '.js');
-        if (this.platforms.length == 1)
-            return ext;
-        return "."+platform+ext;
-    }
-    /**
-     * @returns {RollupOptions[]}
-     */
-    getConfig() {
-        if (this.options.external && typeof this.options.external === "string")
-            this.options.external = [this.options.external]
-        // console.log(this.options.name, this.options);
-        return this.modules.flatMap(format => this.platforms.map(platform => ({
-            entryPoints: [
-                { out: this.options.name, in: this.options.input }
-            ],
-            bundle: true,
-            minify: this.options.minify,
-            sourcemap: this.options.prod ? false : 'external',
-            target: ['chrome88', 'safari14', 'firefox88'],
-            outdir: 'dist/bundle',
-            metafile: true,
-            absWorkingDir: this.root,
-            treeShaking: this.options.prod,
-            format: ({
-                es: 'esm'
-            })[format] ?? format,
-            outExtension: {
-                '.js': this.getOutExtension(format, platform),
-                '.css': this.options.minify ? '.min.css' : '.css'
-            },
-            footer:{
-                js: `//# sourceMappingURL=./${this.options.name+this.getOutExtension(format, platform)}.map`
-            },
-            platform: platform,
-            tsconfig: 'tsconfig.json',
-            external: [
-                "*.woff2", "*.woff",
-                ...(platform !== "node" && this.options.minify ? [] : this.options.external)
-            ],
-            define: {
-                'process.env.NODE_ENV': '"production"',
-                PRODUCTION: this.options.prod ? "true": "false"
-            },
-            publicPath: '/',
-            alias: this.options.alias,
-            plugins: [
-                lessLoader(),
-                ...this.getHtmlPlugin(),
-                ...(this.options.noSideEffects ? [{
-                    name: 'no-side-effects',
-                    setup(build){
-                        build.onResolve({ filter: /.*/ }, async args => {
-                            if (args.pluginData) return // Ignore this if we called ourselves
-
-                            const { path, ...rest } = args
-                            rest.pluginData = true // Avoid infinite recursion
-                            const result = await build.resolve(path, rest)
-
-                            result.sideEffects = false
-                            return result
-                        })
-                    }
-                }] : [])
-            ],
-        })));
-    }
-}

package/bundle/getConfigs.js

@@ -1,62 +0,0 @@
-import fs from "fs";
-import path from "path";
-import {getTSConfig} from "../helpers/getTSConfig.js";
-
-function getProjectConfig(rootDir, cmmn, options) {
-    return {
-        ...options,
-        ...cmmn,
-        rootDir: rootDir
-    };
-}
-
-async function *getDependencyOrder(rootDir, visited = []) {
-    const tsConfig = getTSConfig(rootDir)
-    for (let reference of tsConfig.references ?? []){
-        const refRoot = path.resolve(rootDir, reference.path);
-        if (visited.includes(refRoot))
-            continue;
-        visited.push(refRoot)
-        for await (let dep of await getDependencyOrder(refRoot, visited)){
-            yield dep;
-        }
-    }
-    yield rootDir;
-}
-
-
-async function getPackageConfigs(rootDir, options, name = null, visited = []) {
-    const pckPath = path.join(rootDir, 'package.json');
-    if (!fs.existsSync(pckPath))
-        return [];
-    const results = [];
-    const pkg = JSON.parse(await fs.promises.readFile(pckPath));
-    if (pkg.cmmn) {
-        if (name) {
-            results.push(getProjectConfig(rootDir, pkg.cmmn[name], {
-                ...options,
-                name,
-                package: pkg.name,
-            }));
-        } else {
-            for (let name in pkg.cmmn) {
-                results.push(getProjectConfig(rootDir, pkg.cmmn[name], {
-                    ...options,
-                    name,
-                    package: pkg.name,
-                }));
-            }
-        }
-    }
-    return results;
-}
-
-
-export async function getConfigOptions(options) {
-    const result = []
-    for await (let project of getDependencyOrder(process.cwd())){
-        const configs = await getPackageConfigs(project, options);
-        result.push(...configs);
-    }
-    return result;
-}

package/compile/compile.js

@@ -1,53 +0,0 @@
-import ts from "typescript";
-import {resolve, relative} from 'node:path';
-import fs from "node:fs";
-import { tsResolvePlugin } from "./ts-resolve-plugin.js";
-
-const rootDir = process.cwd();
-
-export function compile(...flags) {
-
-    const host = ts.createSolutionBuilderWithWatchHost(ts.sys, createProgram);
-    host.getCustomTransformers = (pkg) => ({
-        before: [
-            tsResolvePlugin
-        ],
-        afterDeclarations: [
-            tsResolvePlugin
-        ]
-    });
-    host.useCaseSensitiveFileNames();
-
-    const builderFactory = flags.includes('--watch') ?
-        ts.createSolutionBuilderWithWatch :
-        ts.createSolutionBuilder;
-
-    const builder = builderFactory(host, [rootDir], {
-        incremental: true,
-        dry: false,
-        assumeChangesOnlyAffectDirectDependencies: true
-    }, {
-        excludeDirectories: ["node_modules", "dist"],
-    });
-        builder.clean(rootDir);
-        builder.build(rootDir);
-}
-const cleanedBaseDirs = new Set();
-function createProgram(rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences) {
-    options.outDir = resolve(options.configFilePath, '../dist/esm');
-    options.declarationDir = resolve(options.configFilePath, '../dist/typings');
-    options.baseUrl = resolve(options.configFilePath, '../');
-    options.tsBuildInfoFile = resolve(options.configFilePath, '../dist/ts.buildinfo');
-    // options.excludeDirectories.baseUrl = options.baseUrl;
-    // options.includeDirectories.baseUrl = options.baseUrl;
-    if (!cleanedBaseDirs.has(options.baseUrl)){
-        fs.rmSync(options.outDir, {recursive: true, force: true});
-        fs.rmSync(options.declarationDir, {recursive: true, force: true});
-        fs.rmSync(options.tsBuildInfoFile, {force: true});
-        cleanedBaseDirs.add(options.baseUrl);
-    }
-    console.log('\t', relative(process.cwd(), options.baseUrl));
-    return ts.createEmitAndSemanticDiagnosticsBuilderProgram(
-        rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences
-    )
-}

package/compile/ts-resolve-plugin.js

@@ -1,235 +0,0 @@
-import ts from "typescript";
-import path from "path";
-import fs from "fs";
-import { ImportPathsResolver } from '@zerollup/ts-helpers'
-
-class Visitor {
-    /**
-     * @type {ImportPathsResolver}
-     */
-    resolver;
-    /**
-     * @type {ts.TransformationContext}
-     */
-    context;
-    /**
-     * @type {ts.CompilerOptions}
-     */
-    options;
-    /**
-     * @type {{
-     *     copy: RegExp;
-     *     import: RegExp;
-     * }}
-     */
-    config;
-    /**
-     *
-     * @param context {ts.TransformationContext}
-     */
-    constructor(context, config) {
-        this.context = context;
-        this.options = context.getCompilerOptions();
-        this.resolver = new ImportPathsResolver({
-            paths: this.options.paths,
-            baseUrl: this.options.baseUrl,
-            exclude: []
-        });
-        this.config = {
-            copy: /\.(less|css|scss|sass|png|jpg|ico)$/,
-            import: /\.(txt|sql|svg|html)$/,
-            ...config
-        }
-    }
-    findFile(importPath, sourceFile) {
-        const sourceFileDir = path.dirname(sourceFile.fileName);
-
-        return [
-            importPath,
-            importPath + "/index.ts",
-            importPath + ".ts",
-            importPath + ".tsx",
-            importPath + "/index.js",
-            importPath + ".js",
-            importPath + ".jsx",
-            importPath.replace(/\.js$/, ".ts")
-        ].find(x => fs.existsSync(path.resolve(sourceFileDir, x)))?.replace(/(\.ts)x?$/, '.js');
-    }
-    resolveFile(importPath, sourceFile){
-        const sourceFileDir = path.dirname(sourceFile.fileName);
-        const existed = this.findFile(importPath, sourceFile);
-        if (existed) return existed;
-        const suggestions = this.resolver.getImportSuggestions(importPath, sourceFileDir) ?? [];
-        for (let suggestion of suggestions) {
-            const existed = this.findFile(suggestion, sourceFile)
-            if (existed) return existed;
-        }
-        return importPath;
-    }
-    /**
-     * @param importPath {string}
-     * @param sourceFile {ts.SourceFile}
-     */
-    resolve(importPath, sourceFile){
-        importPath = this.resolveFile(importPath, sourceFile);
-        const sourceFileDir = path.dirname(sourceFile.fileName);
-        const absSource = path.join(this.options.outDir, path.relative(this.options.baseUrl, sourceFileDir));
-        const abs = path.resolve(sourceFileDir, importPath);
-        if (this.config.import.test(importPath)) {
-            const content = fs.readFileSync(path.resolve(sourceFileDir, importPath), 'utf-8');
-            const outFile = path.resolve(absSource, importPath).replaceAll(path.sep, '/') + '.js';
-            fs.mkdirSync(path.dirname(outFile), {recursive: true});
-            fs.writeFileSync(outFile, 'export default `'+content.replaceAll('`','\\`')+'`', 'utf-8');
-            return importPath.replaceAll(path.sep, '/') + ".js";
-        }
-        if (this.config.copy.test(importPath)) {
-            return  path.relative(absSource,abs).replaceAll(path.sep, '/');
-        }
-        return importPath.replaceAll(path.sep, '/');
-    }
-
-    visitSourceFile = sourceFile => ts.visitEachChild(sourceFile, node => this.visit(node,sourceFile), this.context);
-
-    /**
-     * @param node {ts.Node}
-     * @param sourceFile {ts.SourceFile}
-     */
-    visit(node,sourceFile){
-        // if (node && node.kind == SyntaxKind.ImportDeclaration) {
-        //     return visitImportNode(node as ts.ImportDeclaration);
-        // }
-        if (!node)
-            return ts.visitEachChild(node, this.visit, this.context);
-        if (ts.isCallExpression(node)) {
-            const result = this.visitRequireNode(node, sourceFile);
-            if (result)
-                return result;
-        }
-        if (ts.isImportDeclaration(node)) {
-            const result = this.visitImportNode(node, sourceFile);
-            if (result)
-                return result;
-        }
-        if (ts.isExportDeclaration(node)) {
-            const result = this.visitExportNode(node, sourceFile);
-            if (result)
-                return result;
-        }
-        return ts.visitEachChild(node, node => this.visit(node, sourceFile), this.context);
-    }
-
-
-    /**
-     * @param exportNode {ts.ExportDeclaration}
-     * @param sourceFile {ts.SourceFile}
-     */
-    visitExportNode(exportNode, sourceFile) {
-        if (exportNode.typeOnly){
-            console.log('type olnly')
-            return ;
-        }
-        const file = exportNode.moduleSpecifier?.text ?? exportNode.text;
-        if (!file)
-            return;
-
-        const resolved = this.resolve(file, sourceFile);
-
-        const newNode = this.context.factory.updateExportDeclaration(
-            exportNode,
-            exportNode.decorators,
-            exportNode.modifiers,
-            exportNode.exportClause,
-            this.context.factory.createStringLiteral(resolved),
-            exportNode.typeOnly
-        );
-        if (newNode.flags !== exportNode.flags) {
-            newNode.flags = exportNode.flags
-        }
-        return newNode;
-    }
-
-    /**
-     * @param importNode {ts.ImportDeclaration}
-     * @param sourceFile {ts.SourceFile}
-     */
-    visitImportNode(importNode, sourceFile) {
-        const file = importNode.moduleSpecifier?.text;
-        if (!file)
-            return;
-        const resolved = this.resolve(file, sourceFile);
-
-        const newNode = this.context.factory.updateImportDeclaration(
-            importNode,
-            importNode.modifiers,
-            importNode.importClause,
-            this.context.factory.createStringLiteral(resolved),
-            importNode.assertClause,
-        );
-        newNode.flags = importNode.flags;
-        return newNode;
-        // const caseSensitiveFileNames = this.context.getEmitHost().useCaseSensitiveFileNames();
-        // const formatPath = caseSensitiveFileNames ? x => x : x => x.toLowerCase();
-        // const sourceFileDir = path.dirname(sourceFile.path);
-        // const abs = formatPath(path.resolve(sourceFileDir, formatPath(file)));
-        // if (/\.(less|css|scss|sass|svg|png|html)$/.test(file)) {
-        //     const absSource = formatPath(path.join(this.options.outDir, formatPath(path.relative(this.options.baseUrl, sourceFileDir))));
-        //     const relFile = path.relative(absSource, abs).replaceAll(path.sep, '/');
-        //     return this.context.factory.updateImportDeclaration(
-        //         importNode,
-        //         importNode.decorators,
-        //         importNode.modifiers,
-        //         importNode.importClause,
-        //         importNode.assertClause,
-        //         this.context.factory.createStringLiteral(relFile)
-        //     );
-        // }
-        // if (/\.(json|tsx?|jsx?)$/.test(file))
-        //     return;
-        // if (fs.existsSync(abs + '.ts') || fs.existsSync(abs + '.tsx')) {
-        //     return this.context.factory.updateImportDeclaration(
-        //         importNode,
-        //         importNode.decorators,
-        //         importNode.modifiers,
-        //         importNode.importClause,
-        //         importNode.assertClause,
-        //         this.context.factory.createStringLiteral(file + '.js')
-        //     );
-        // }
-        // if (fs.existsSync(abs + '/')) {
-        //     const indexFile = `${file}/index.js`;
-        //     return this.context.factory.updateImportDeclaration(
-        //         importNode,
-        //         importNode.decorators,
-        //         importNode.modifiers,
-        //         importNode.importClause,
-        //         importNode.assertClause,
-        //         this.context.factory.createStringLiteral(indexFile)
-        //     );
-        // }
-    }
-
-    /**
-     * @param importNode {ts.Node}
-     * @param sourceFile {ts.SourceFile}
-     */
-    visitRequireNode(importNode, sourceFile) {
-        if (importNode.expression.kind !== ts.SyntaxKind.Identifier ||
-            importNode.expression.escapedText !== "require") {
-            return;
-        }
-        const file = importNode.arguments[0].text;
-        const resolved = this.resolve(file, sourceFile);
-        return this.context.factory.updateCallExpression(
-            importNode,
-            importNode.expression,
-            undefined,
-            [this.context.factory.createStringLiteral(resolved)]
-        );
-    }
-}
-
-export const tsResolvePlugin = function (contextOrOptions) {
-    if(!contextOrOptions.getCompilerOptions)
-        return context => new Visitor(context, contextOrOptions).visitSourceFile;
-    return new Visitor(contextOrOptions).visitSourceFile;
-};

package/compile/typings.d.ts

@@ -1,19 +0,0 @@
-declare module "*.less"{
-    const style: string;
-    export default style;
-}
-
-declare module "*.svg"{
-    const style: string;
-    export default style;
-}
-
-declare module "*.css"{
-    const style: string;
-    export default style;
-}
-
-declare module "*.html"{
-    const style: string;
-    export default style;
-}

package/gen/component.ts.tpl

@@ -1,16 +0,0 @@
-import {component, HtmlComponent, property} from "@cmmn/ui";
-import {template, IState, IEvents} from "./$name$.template";
-import style from "./$name$.style.less";
-import {Injectable} from "@cmmn/core";
-
-@Injectable(true)
-@component({name: '$name$', template, style})
-export class $Name$Component extends HtmlComponent<IState, IEvents> {
-
-    @property()
-    private property!: any;
-
-    get State() {
-        return this.property;
-    }
-}