@moneko/core 3.0.0-beta.8 → 3.0.0-beta.81

package/lib/app.d.ts

@@ -0,0 +1,31 @@
+declare const app: {
+    base: string;
+    designSize: number;
+    routerMode: "browser" | "hash" | "memory";
+    mode: "csr" | "ssr";
+    name: string;
+    description: string | undefined;
+    version: string;
+    author: {
+        name: string | undefined;
+        email: string | undefined;
+        url: string | undefined;
+    };
+    repository: {
+        type: string | undefined;
+        url: string | undefined;
+        directory: string | undefined;
+    };
+    locales: boolean;
+    favicon: string | false | undefined;
+    prefixCls: string | undefined;
+    theme: import("./index.js").Theme | undefined;
+    type: import("./index.js").AppType;
+    persist: boolean;
+    projectName: string;
+    iconfont: {
+        scriptUrl?: string | string[] | undefined;
+        extraCommonProps?: Record<string, any> | undefined;
+    } | undefined;
+};
+export default app;

package/lib/app.js

@@ -0,0 +1,27 @@
+import fs from 'fs';
+import path from 'path';
+import { CONFIG } from './common.js';
+import htmlPluginOption from './html-plugin-option.js';
+import { APPTYPE, PACKAGENAME, PROGRAMPATH, programInfo } from './process-env.js';
+import { toUpperCaseString } from './utils.js';
+const entryName = APPTYPE === 'library' ? 'site' : 'src';
+const app = {
+    base: CONFIG.routeBaseName,
+    designSize: CONFIG.designSize,
+    routerMode: CONFIG.routerMode,
+    mode: CONFIG.mode,
+    name: programInfo.name,
+    description: programInfo.description,
+    version: programInfo.version,
+    author: programInfo.author,
+    repository: programInfo.repository,
+    locales: fs.existsSync(path.join(PROGRAMPATH, `./${entryName}/locales`)),
+    favicon: htmlPluginOption.favicon,
+    prefixCls: CONFIG.prefixCls,
+    theme: CONFIG.theme,
+    type: APPTYPE,
+    persist: fs.existsSync(path.join(PROGRAMPATH, `./${entryName}/persist.ts`)),
+    projectName: JSON.stringify(toUpperCaseString(PACKAGENAME)),
+    iconfont: CONFIG.iconfont
+};
+export default app;

package/lib/cleanup.js

@@ -0,0 +1,19 @@
+import { existsSync, readdirSync, rmdirSync, statSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { cacheDir } from './process-env.js';
+function cleanDir(folderPath) {
+    if (existsSync(folderPath)) {
+        readdirSync(folderPath).forEach((file)=>{
+            const filePath = join(folderPath, file);
+            if (statSync(filePath).isDirectory()) {
+                cleanDir(filePath);
+            } else {
+                unlinkSync(filePath);
+            }
+        });
+        rmdirSync(folderPath);
+    }
+}
+process.on('SIGINT', function() {
+    cleanDir(cacheDir);
+});

package/{build → lib}/common.d.ts

@@ -1,4 +1,4 @@
-import type { AppType, ConfigType } from '../typings/global.d.ts';
+import type { AppType, ConfigType } from '../typings/global.js';
 export declare const ENTRYPATH: Record<AppType, string>;
 export declare const log: (msg: string) => void;
 export declare const CONFIG: ConfigType<"swc">;

package/lib/common.js

@@ -0,0 +1,225 @@
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import chalk from 'chalk';
+import { merge } from 'webpack-merge';
+import { APPTYPE, CUSTOMCONFIG, FRAMEWORK, PROGRAMPATH, jsxImportSource, pkgName } from './process-env.js';
+import { isFunction, readConf } from './utils.js';
+export const ENTRYPATH = {
+    mobile: 'mobile',
+    site: 'site',
+    'back-stage': 'back-stage',
+    'single-spa': 'single-spa',
+    library: 'library',
+    'single-component': 'single-component'
+};
+const includeModule = [
+    `@moneko/${FRAMEWORK}`,
+    'neko-ui',
+    'antd',
+    '@antv',
+    'katex',
+    'font-pingfang-sc',
+    'font-pingfang-tc',
+    'react-photo-view',
+    'react-markdown-editor-lite',
+    'schema-design',
+    'env-flags',
+    '@app'
+];
+let defaultSplitChunk = {
+    chunks: 'all',
+    minSize: 1024,
+    minChunks: 1,
+    cacheGroups: {
+        route: {
+            test: /[\\/].git[\\/]router/,
+            priority: -10,
+            reuseExistingChunk: true,
+            name: 'route'
+        },
+        example: {
+            test: /[\\/].git[\\/]example/,
+            priority: -10,
+            reuseExistingChunk: true,
+            name: 'example'
+        }
+    }
+};
+if (APPTYPE === 'single-component') {
+    defaultSplitChunk = false;
+}
+const defaultConfig = {
+    seo: false,
+    mode: 'csr',
+    compiler: 'swc',
+    bundleAnalyzer: {
+        analyzerMode: 'static',
+        reportFilename: 'report.html',
+        openAnalyzer: false
+    },
+    entry: {},
+    minifier: {
+        js: {},
+        css: {}
+    },
+    sourceMap: {
+        filename: '[file].map',
+        publicPath: ''
+    },
+    env: {},
+    routeBaseName: '/',
+    publicPath: '/',
+    designSize: APPTYPE === 'mobile' ? 375 : 1680,
+    fallbackCompPath: null,
+    modifyVars: {},
+    prefixCls: 'n',
+    alias: {},
+    layoutSider: {},
+    moduleRules: [],
+    prefixJsLoader: [],
+    cssModules: [],
+    importOnDemand: {},
+    proxy: [],
+    cacheDirectory: `${PROGRAMPATH}/node_modules/.temp_cache`,
+    devServer: {
+        allowedHosts: [
+            '.baidu.com'
+        ],
+        host: 'localhost',
+        port: 3000,
+        https: false,
+        compress: false
+    },
+    htmlPluginOption: {
+        template: `./node_modules/${pkgName}/template/index.html`,
+        favicon: `./node_modules/${pkgName}/template/favicon.ico`,
+        tags: []
+    },
+    assetHtml: [],
+    routerMode: 'browser',
+    fixBrowserRouter: false,
+    plugins: [],
+    splitChunk: defaultSplitChunk,
+    runtimeChunk: APPTYPE === 'single-component' ? false : 'single',
+    moduleFederation: [],
+    rulesInclude: {
+        less: includeModule,
+        css: includeModule,
+        js: includeModule,
+        media: includeModule,
+        fonts: includeModule
+    },
+    mdx: {
+        jsxImportSource: jsxImportSource,
+        useDynamicImport: true,
+        remarkPlugins: [],
+        rehypePlugins: []
+    },
+    jsxDomExpressions: {
+        moduleName: 'solid-js/web',
+        builtIns: [
+            'For',
+            'Show',
+            'Switch',
+            'Match',
+            'Suspense',
+            'SuspenseList',
+            'Portal',
+            'Index',
+            'Dynamic',
+            'ErrorBoundary'
+        ],
+        contextToCustomElements: true,
+        wrapConditionals: true,
+        generate: 'dom',
+        hydratable: false
+    },
+    bar: {
+        name: '编译中',
+        color: '#6f42c1'
+    }
+};
+export const log = (msg)=>{
+    readline.cursorTo(process.stdout, 0);
+    process.stdout.write(msg);
+};
+let customConf = defaultConfig;
+let configPath = null;
+let normalConf = {};
+let envConf = {};
+try {
+    configPath = path.join(PROGRAMPATH, './config/index.ts');
+    fs.accessSync(configPath, fs.constants.R_OK);
+} catch (error) {
+    configPath = null;
+}
+if (configPath) {
+    try {
+        const conf = (await readConf(configPath, 'index')).default;
+        normalConf = isFunction(conf) ? conf(process) : conf;
+    } catch (error) {
+        process.stdout.write(chalk.red(error));
+    }
+}
+if (CUSTOMCONFIG) {
+    let customConfigPath = null;
+    try {
+        customConfigPath = path.join(PROGRAMPATH, `./config/${CUSTOMCONFIG}.ts`);
+        fs.accessSync(customConfigPath, fs.constants.R_OK);
+    } catch (error) {
+        customConfigPath = null;
+    }
+    if (customConfigPath !== null) {
+        try {
+            const conf = (await readConf(customConfigPath, CUSTOMCONFIG)).default;
+            envConf = isFunction(conf) ? conf(process) : conf;
+        } catch (error) {
+            process.stdout.write(chalk.red(error));
+        }
+    }
+}
+customConf = merge(customConf, normalConf, envConf);
+if (customConf.compiler === 'tsc' && customConf.minifier) {
+    if (!customConf.minifier.js) {
+        Object.assign(customConf.minifier, {
+            js: {
+                type: 'terser'
+            }
+        });
+    }
+    if (!customConf.minifier.css) {
+        Object.assign(customConf.minifier, {
+            css: {
+                type: 'cssnano'
+            }
+        });
+    }
+}
+if (customConf.devtool === false) customConf.sourceMap = false;
+if (customConf.sourceMap === false) customConf.devtool = false;
+if (customConf.fixBrowserRouter && customConf.htmlPluginOption) {
+    if (!customConf.htmlPluginOption.tags) {
+        customConf.htmlPluginOption.tags = [];
+    }
+    customConf.htmlPluginOption.tags.push({
+        textContent: `
+        (function(l) {
+          if (l.search[1] === '/' ) {
+            var decoded = l.search.slice(1).split('&').map(function(s) { 
+              return s.replace(/~and~/g, '&')
+            }).join('?');
+            window.history.replaceState(null, null,
+                l.pathname.slice(0, -1) + decoded + l.hash
+            );
+          }
+        }(window.location))
+      `
+    });
+}
+export const CONFIG = customConf;
+export const PUBLICPATH = CONFIG.publicPath || '/';
+global.NEKOCLICONFIG = {
+    CONFIG,
+    log
+};

package/{build → lib}/coverage.d.ts

@@ -1,2 +1,2 @@
-import type { CoverageType, ProjectCoverageType } from '../typings/global.d.ts';
+import type { CoverageType, ProjectCoverageType } from '../typings/global.js';
 export declare const coverage: Record<string, CoverageType & Partial<ProjectCoverageType>>;

package/lib/coverage.js

@@ -0,0 +1,30 @@
+import { accessSync, constants, readFileSync } from 'fs';
+import { join } from 'path';
+import { Parser } from 'xml2js';
+import { PACKAGENAME, PROGRAMPATH } from './process-env.js';
+export const coverage = {};
+try {
+    const coveragePath = join(PROGRAMPATH, './coverage/clover.xml');
+    accessSync(coveragePath, constants.R_OK);
+    const parser = new Parser({
+        explicitArray: false,
+        async: false
+    });
+    const cover = readFileSync(coveragePath, {
+        encoding: 'utf-8'
+    });
+    parser.parseString(cover, (error, result)=>{
+        if (!error) {
+            const projectMetrics = result.coverage.project.metrics.$;
+            const components = result.coverage.project.package;
+            Object.assign(coverage, {
+                [PACKAGENAME]: projectMetrics
+            });
+            components.forEach((pkg)=>{
+                Object.assign(coverage, {
+                    [pkg.$.name]: pkg.metrics.$
+                });
+            });
+        }
+    });
+} catch (error) {}

package/lib/define.d.ts

@@ -0,0 +1,6 @@
+declare const define: {
+    'process.env': {
+        NODE_ENV: string | undefined;
+    };
+};
+export default define;

package/lib/define.js

@@ -0,0 +1,9 @@
+import { CONFIG } from './common.js';
+import { NODE_ENV } from './process-env.js';
+const define = {
+    'process.env': {
+        NODE_ENV: NODE_ENV,
+        ...CONFIG.env
+    }
+};
+export default define;

package/lib/docs.d.ts

@@ -0,0 +1 @@
+export declare const envApi: Record<string, string>;

package/lib/docs.js

@@ -0,0 +1,118 @@
+import { statSync } from 'fs';
+import { dirname, join } from 'path';
+import { watch } from 'chokidar';
+import generateApi from './generate-api.js';
+import { APPTYPE, FRAMEWORK } from './process-env.js';
+import { resolveNodeModulesPath, resolveProgramPath } from './utils.js';
+import { vm } from './virtual-module-plugin.js';
+import { alias } from './webpack.common.js';
+const base = '@app/md';
+const apiEntry = '@app/docs';
+export const envApi = {};
+const cacheEnvApi = {
+    [base]: {}
+};
+const createElement = {
+    react: 'createElement',
+    'solid-js': 'createComponent'
+}[FRAMEWORK];
+let replaceStr = `() => ${createElement}(SuspenseComp, { comp: $1 })`;
+let prefixStr = `import { ${createElement} } from "${FRAMEWORK}";import { SuspenseComp } from "@moneko/${FRAMEWORK}";`;
+if (![
+    'react',
+    'solid-js'
+].includes(FRAMEWORK)) {
+    replaceStr = '$1';
+    prefixStr = '';
+}
+if (FRAMEWORK === 'solid-js') {
+    prefixStr = `import { Dynamic } from "${FRAMEWORK}/web";${prefixStr}`;
+}
+function handleFileChange(filePath, changeType) {
+    const fil = filePath.replace(new RegExp(`^${alias['@pkg']}`), '');
+    const __dir = dirname(fil).replace(/^\//, '');
+    const apiDir = [
+        base,
+        __dir
+    ].join('/');
+    const name = fil.split('/').pop()?.replace(/\.tsx?/, '.md');
+    if (!name) return;
+    if (!cacheEnvApi[base][__dir]) {
+        cacheEnvApi[base][__dir] = {};
+    }
+    const target = join(apiDir, name);
+    if (changeType === 'deleted') {
+        if (cacheEnvApi[base][__dir][name]) {
+            delete cacheEnvApi[base][__dir][name];
+        }
+    } else {
+        const api = generateApi(filePath);
+        cacheEnvApi[target] = api;
+        if (api) {
+            cacheEnvApi[base][__dir][name] = `rr(() => import(/* webpackChunkName: '${target}' */'${target}?raw').then((res) => ({default: ${createElement}(Dynamic, {text: res.default, component: 'n-md'})})))rr`;
+        } else if (cacheEnvApi[base][__dir][name]) {
+            delete cacheEnvApi[base][__dir][name];
+        }
+    }
+    const basestr = {};
+    for(const k in cacheEnvApi[base]){
+        if (Object.prototype.hasOwnProperty.call(cacheEnvApi[base], k)) {
+            basestr[k] = Object.values(cacheEnvApi[base][k]);
+        }
+    }
+    const env = {
+        ...cacheEnvApi
+    };
+    delete env[base];
+    Object.assign(envApi, {
+        ...env,
+        [apiEntry]: `${prefixStr}export default ${JSON.stringify(basestr).replace(/"rr\((.+?)\)rr"/g, replaceStr)}`
+    });
+    for(const key in envApi){
+        if (Object.prototype.hasOwnProperty.call(envApi, key)) {
+            vm?.writeModule(resolveNodeModulesPath(key), envApi[key]);
+        }
+    }
+}
+function watchDirectory() {
+    const files = [];
+    const watcher = watch(resolveProgramPath('components'), {
+        ignored: [
+            /(^|[\\/\\])\../,
+            /(^|[\\/\\])__tests__([\\/\\]|$)/
+        ],
+        persistent: true,
+        ignoreInitial: false
+    });
+    function isTs(path) {
+        return /\.tsx?$/.test(path) && statSync(path).isFile();
+    }
+    watcher.on('add', (path)=>{
+        if (isTs(path)) {
+            handleFileChange(path, 'added');
+            files.push(path);
+        }
+    });
+    watcher.on('change', (path)=>{
+        if (isTs(path)) {
+            handleFileChange(path, 'change');
+        }
+    });
+    watcher.on('unlink', (path)=>{
+        if (isTs(path)) {
+            handleFileChange(path, 'deleted');
+            files.splice(files.indexOf(path), 1);
+        }
+    });
+    watcher.on('ready', ()=>{
+        files.forEach((f)=>{
+            handleFileChange(f, 'change');
+        });
+    });
+    process.on('SIGINT', function() {
+        watcher.close();
+    });
+}
+if (APPTYPE === 'library') {
+    watchDirectory();
+}

package/{build → lib}/done.d.ts

@@ -1,3 +1,4 @@
+import { type Compiler } from 'webpack';
 declare class DoneWebpackPlugin {
     options: {
         done?: () => void;
@@ -5,12 +6,6 @@ declare class DoneWebpackPlugin {
     constructor(options: {
         done?: () => void;
     });
-    apply(compiler: {
-        hooks: {
-            done: {
-                tap: (arg0: string, arg1: () => void) => void;
-            };
-        };
-    }): void;
+    apply(compiler: Compiler): void;
 }
 export default DoneWebpackPlugin;

package/lib/done.js

@@ -0,0 +1,12 @@
+class DoneWebpackPlugin {
+    options;
+    constructor(options){
+        this.options = Object.assign({}, options);
+    }
+    apply(compiler) {
+        compiler.hooks.done.tap('DoneWebpackPlugin', ()=>{
+            this.options.done?.();
+        });
+    }
+}
+export default DoneWebpackPlugin;

package/lib/esm.d.ts

@@ -0,0 +1 @@
+export default function esm(templateStrings: TemplateStringsArray, ...substitutions: unknown[]): string;

package/lib/esm.js

@@ -0,0 +1,7 @@
+export default function esm(templateStrings, ...substitutions) {
+    let js = templateStrings.raw[0];
+    for(let i = 0; i < substitutions.length; i++){
+        js += substitutions[i] + templateStrings.raw[i + 1];
+    }
+    return `data:text/javascript;base64,${Buffer.from(js).toString('base64')}`;
+}

package/lib/generate-api.d.ts

@@ -0,0 +1 @@
+export default function generateApi(path: string): string;