@moneko/core 3.0.0-beta.30 → 3.0.0-beta.32

package/lib/module.config.js

@@ -1 +1,184 @@
-import e from"mini-css-extract-plugin";import s from"mini-svg-data-uri";import{CONFIG as o,PUBLICPATH as t}from"./common.js";import{hasPkg as l}from"./has-pkg.js";import r from"./modifyVars.js";import{APPTYPE as a,DEV as i,FRAMEWORK as n}from"./process-env.js";import c from"./swcrc.js";import m from"./tsloader.config.js";import{resolveNodeModulesPath as p,resolveProgramPath as d}from"./utils.js";let u="single-spa"===a?t:"../",f={loader:e.loader,options:{publicPath:"/"!==u?u:"../"}},y=l("@moneko/postcss")&&{loader:"postcss-loader",options:{postcssOptions:await import("@moneko/postcss")}};i&&(f="style-loader");let x=[...o.cssModules,`@moneko/${n}`,"neko-ui"].map(p),g=[...["src/styles/variables/*.less","src/styles/mixins/*.less","site/styles/variables/*.less","site/styles/mixins/*.less"].map(d)],$=["components","example","mock","site","src"].map(d),j=[f,{loader:"css-loader",options:{modules:{auto:e=>{for(let s=0,o=x.length;s<o;s++)if(e&&e?.includes(x[s]))return/(.*(?<!\.global\.(le|c)ss)$)/i.test(e);return/(^(?!.*node_modules))(.*(?<!\.global\.(le|c)ss)$)/i.test(e)},localIdentName:"[path][name]__[local]",exportLocalsConvention:"dashesOnly"},importLoaders:2}},y,"css-unicode-loader",{loader:"less-loader",options:{sourceMap:!!o.sourceMap,lessOptions:{modifyVars:r,javascriptEnabled:!0}}},{loader:"style-resources-loader",options:{patterns:g}}].filter(Boolean),b={loader:"tsc"===o.compiler?"ts-loader":"swc-loader",options:"tsc"===o.compiler?m:c(i)},v={rules:[{oneOf:[{resourceQuery:/raw/,type:"asset/source"},{resourceQuery:/\.wasm$/,type:"webassembly/async"},{test:/\.less$/,use:j,include:$.concat(o.rulesInclude?.less?.map(p)||[])},{test:/\.css$/,use:[f,"css-loader",y,"css-unicode-loader"].filter(Boolean),include:$.concat(o.rulesInclude?.css?.map(p)||[])},{test:/\.(gif|png|jpe?g|ico|mp4)$/i,type:"asset",generator:{filename:"assets/images/[name][ext][query]"},include:$.concat(o.rulesInclude?.media?.map(p)||[])},{test:/\.(eot|ttf|otf|woff(|2))$/,type:"asset",generator:{filename:"assets/fonts/[name][ext][query]"},include:$.concat(o.rulesInclude?.fonts?.map(p)||[])},{test:/\.svg$/,type:"asset/inline",generator:{dataUrl:e=>s("string"!=typeof e?e.toString():e)}},{test:/\.txt$/,type:"asset/source"},{test:/\.(cj|mj|t|j)s(|x)$/,use:[...o.prefixJsLoader,b].filter(Boolean),include:$.concat(o.rulesInclude?.js?.map(p)||[])},{test:/\.mdx?$/,use:[...o.prefixJsLoader,b,{loader:"@mdx-js/loader",options:o.mdx}].filter(Boolean),include:$,exclude:[/(.+)\/examples\/(.+).mdx?$/i]},{test:/\.mdx?$/,type:"asset/source",include:[/(.+)\/examples\/(.+).mdx?$/i]},{type:"asset/source",include:[/(.+)\/examples\/(.+).*?$/i]}]},...o.moduleRules]};export default v;
+import MiniCssExtractPlugin from 'mini-css-extract-plugin';
+import svgToMiniDataURI from 'mini-svg-data-uri';
+import { CONFIG, PUBLICPATH } from './common.js';
+import { hasPkg } from './has-pkg.js';
+import modifyVars from './modifyVars.js';
+import { APPTYPE, DEV, FRAMEWORK } from './process-env.js';
+import swcOption from './swcrc.js';
+import tsLoaderConfig from './tsloader.config.js';
+import { resolveNodeModulesPath, resolveProgramPath } from './utils.js';
+const cssAssetsPublicPath = APPTYPE === 'single-spa' ? PUBLICPATH : '../';
+let styleLoader = {
+    loader: MiniCssExtractPlugin.loader,
+    options: {
+        publicPath: cssAssetsPublicPath !== '/' ? cssAssetsPublicPath : '../'
+    }
+};
+const postcssLoader = hasPkg('@moneko/postcss') && {
+    loader: 'postcss-loader',
+    options: {
+        postcssOptions: await import('@moneko/postcss')
+    }
+};
+if (DEV) {
+    styleLoader = 'style-loader';
+}
+const customCssModules = [
+    ...CONFIG.cssModules,
+    `@moneko/${FRAMEWORK}`,
+    'neko-ui'
+].map(resolveNodeModulesPath);
+const styleResources = [
+    ...[
+        'src/styles/variables/*.less',
+        'src/styles/mixins/*.less',
+        'site/styles/variables/*.less',
+        'site/styles/mixins/*.less'
+    ].map(resolveProgramPath)
+];
+const entryResolveProgramPath = [
+    'components',
+    'example',
+    'mock',
+    'site',
+    'src'
+].map(resolveProgramPath);
+const lessLoaderRule = [
+    styleLoader,
+    {
+        loader: 'css-loader',
+        options: {
+            modules: {
+                auto: (resourcePath)=>{
+                    for(let i = 0, len = customCssModules.length; i < len; i++){
+                        if (resourcePath && resourcePath?.includes(customCssModules[i])) {
+                            return /(.*(?<!\.global\.(le|c)ss)$)/i.test(resourcePath);
+                        }
+                    }
+                    return /(^(?!.*node_modules))(.*(?<!\.global\.(le|c)ss)$)/i.test(resourcePath);
+                },
+                localIdentName: '[path][name]__[local]',
+                exportLocalsConvention: 'dashesOnly'
+            },
+            importLoaders: 2
+        }
+    },
+    postcssLoader,
+    'css-unicode-loader',
+    {
+        loader: 'less-loader',
+        options: {
+            sourceMap: !!CONFIG.sourceMap,
+            lessOptions: {
+                modifyVars: modifyVars,
+                javascriptEnabled: true
+            }
+        }
+    },
+    {
+        loader: 'style-resources-loader',
+        options: {
+            patterns: styleResources
+        }
+    }
+].filter(Boolean);
+const tsLoader = {
+    loader: CONFIG.compiler === 'tsc' ? 'ts-loader' : 'swc-loader',
+    options: CONFIG.compiler === 'tsc' ? tsLoaderConfig : swcOption(DEV)
+};
+const moduleOptions = {
+    rules: [
+        {
+            oneOf: [
+                {
+                    resourceQuery: /raw/,
+                    type: 'asset/source'
+                },
+                {
+                    resourceQuery: /\.wasm$/,
+                    type: 'webassembly/async'
+                },
+                {
+                    test: /\.less$/,
+                    use: lessLoaderRule,
+                    include: entryResolveProgramPath.concat(CONFIG.rulesInclude?.less?.map(resolveNodeModulesPath) || [])
+                },
+                {
+                    test: /\.css$/,
+                    use: [
+                        styleLoader,
+                        'css-loader',
+                        postcssLoader,
+                        'css-unicode-loader'
+                    ].filter(Boolean),
+                    include: entryResolveProgramPath.concat(CONFIG.rulesInclude?.css?.map(resolveNodeModulesPath) || [])
+                },
+                {
+                    test: /\.(gif|png|jpe?g|ico|mp4)$/i,
+                    type: 'asset',
+                    generator: {
+                        filename: 'assets/images/[name][ext][query]'
+                    },
+                    include: entryResolveProgramPath.concat(CONFIG.rulesInclude?.media?.map(resolveNodeModulesPath) || [])
+                },
+                {
+                    test: /\.(eot|ttf|otf|woff(|2))$/,
+                    type: 'asset',
+                    generator: {
+                        filename: 'assets/fonts/[name][ext][query]'
+                    },
+                    include: entryResolveProgramPath.concat(CONFIG.rulesInclude?.fonts?.map(resolveNodeModulesPath) || [])
+                },
+                {
+                    test: /\.svg$/,
+                    type: 'asset/inline',
+                    generator: {
+                        dataUrl: (content)=>svgToMiniDataURI(typeof content !== 'string' ? content.toString() : content)
+                    }
+                },
+                {
+                    test: /\.txt$/,
+                    type: 'asset/source'
+                },
+                {
+                    test: /\.(cj|mj|t|j)s(|x)$/,
+                    use: [
+                        ...CONFIG.prefixJsLoader,
+                        tsLoader
+                    ].filter(Boolean),
+                    include: entryResolveProgramPath.concat(CONFIG.rulesInclude?.js?.map(resolveNodeModulesPath) || [])
+                },
+                {
+                    test: /\.mdx?$/,
+                    use: [
+                        ...CONFIG.prefixJsLoader,
+                        tsLoader,
+                        {
+                            loader: '@mdx-js/loader',
+                            options: CONFIG.mdx
+                        }
+                    ].filter(Boolean),
+                    include: entryResolveProgramPath,
+                    exclude: [
+                        /(.+)\/examples\/(.+).mdx?$/i
+                    ]
+                },
+                {
+                    test: /\.mdx?$/,
+                    type: 'asset/source',
+                    include: [
+                        /(.+)\/examples\/(.+).mdx?$/i
+                    ]
+                },
+                {
+                    type: 'asset/source',
+                    include: [
+                        /(.+)\/examples\/(.+).*?$/i
+                    ]
+                }
+            ]
+        },
+        ...CONFIG.moduleRules
+    ]
+};
+export default moduleOptions;

package/lib/process-env.js

@@ -1 +1,63 @@
-import{readFileSync as e,existsSync as o,mkdirSync as r}from"fs";import{join as s}from"path";import t from"url";import{hasPkg as n}from"./has-pkg.js";import{resolveProgramPath as p}from"./utils.js";import c from"./yarn-argv.js";export const __dirname=t.fileURLToPath(new URL(".",import.meta.url));export const APPTYPE=process.env.APPTYPE;export const FRAMEWORK=process.env.FRAMEWORK;export const jsxImportSource={react:"react","solid-js":"solid-js/h"}[FRAMEWORK];export const PROGRAMPATH=process.cwd();export const PACKAGENAME=process.env.npm_package_name;export const PACKAGEVERSION=process.env.npm_package_version;let a=e(s(__dirname,"../package.json"),{encoding:"utf-8"});export const cacheDir=s(PROGRAMPATH,"./node_modules/.cache/@moneko/cli/");o(cacheDir)||r(cacheDir,{recursive:!0});export const pkgName=JSON.parse(a).name;export const NODE_ENV=process.env.NODE_ENV;export const CUSTOMCONFIG=process.env.npm_config_config||c.config;export const DEV="development"===process.env.NODE_ENV;export let hasEslintConfig=!!Object.keys(process.env).filter(e=>e.startsWith("npm_package_eslintConfig_")).length;export let hasStylelintConfig=!!Object.keys(process.env).filter(e=>e.startsWith("npm_package_stylelint_")).length;export const hasAntd=n("antd");export const programInfo={name:PACKAGENAME,version:PACKAGEVERSION,type:APPTYPE,description:process.env.npm_package_description,author:{name:process.env.npm_package_author_name,email:process.env.npm_package_author_email,url:process.env.npm_package_author_url},repository:{type:process.env.npm_package_repository_type,url:process.env.npm_package_repository_url,directory:process.env.npm_package_repository_directory}};if(parseInt(process.versions.node)>14){let o=e(p("package.json"),{encoding:"utf-8"}),{description:r,author:s,repository:t,eslintConfig:n,stylelint:c}=JSON.parse(o);programInfo.author="string"==typeof s?{name:s}:s,programInfo.repository="string"==typeof s?{url:t}:t,programInfo.description=r,hasEslintConfig=!!n,hasStylelintConfig=!!c}
+import { readFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import url from 'url';
+import { hasPkg } from './has-pkg.js';
+import { resolveProgramPath } from './utils.js';
+import yarnArgv from './yarn-argv.js';
+export const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+export const APPTYPE = process.env.APPTYPE;
+export const FRAMEWORK = process.env.FRAMEWORK;
+export const jsxImportSource = {
+    react: 'react',
+    'solid-js': 'solid-js/h'
+}[FRAMEWORK];
+export const PROGRAMPATH = process.cwd();
+export const PACKAGENAME = process.env.npm_package_name;
+export const PACKAGEVERSION = process.env.npm_package_version;
+const pkg = readFileSync(join(__dirname, '../package.json'), {
+    encoding: 'utf-8'
+});
+export const cacheDir = join(PROGRAMPATH, './node_modules/.cache/@moneko/cli/');
+if (!existsSync(cacheDir)) {
+    mkdirSync(cacheDir, {
+        recursive: true
+    });
+}
+export const pkgName = JSON.parse(pkg).name;
+export const NODE_ENV = process.env.NODE_ENV;
+export const CUSTOMCONFIG = process.env.npm_config_config || yarnArgv.config;
+export const DEV = process.env.NODE_ENV === 'development';
+export let hasEslintConfig = !!Object.keys(process.env).filter((k)=>k.startsWith('npm_package_eslintConfig_')).length;
+export let hasStylelintConfig = !!Object.keys(process.env).filter((k)=>k.startsWith('npm_package_stylelint_')).length;
+export const hasAntd = hasPkg('antd');
+export const programInfo = {
+    name: PACKAGENAME,
+    version: PACKAGEVERSION,
+    type: APPTYPE,
+    description: process.env.npm_package_description,
+    author: {
+        name: process.env.npm_package_author_name,
+        email: process.env.npm_package_author_email,
+        url: process.env.npm_package_author_url
+    },
+    repository: {
+        type: process.env.npm_package_repository_type,
+        url: process.env.npm_package_repository_url,
+        directory: process.env.npm_package_repository_directory
+    }
+};
+if (parseInt(process.versions.node) > 14) {
+    const ikpg = readFileSync(resolveProgramPath('package.json'), {
+        encoding: 'utf-8'
+    });
+    const { description , author , repository , eslintConfig , stylelint  } = JSON.parse(ikpg);
+    programInfo.author = typeof author === 'string' ? {
+        name: author
+    } : author;
+    programInfo.repository = typeof author === 'string' ? {
+        url: repository
+    } : repository;
+    programInfo.description = description;
+    hasEslintConfig = !!eslintConfig;
+    hasStylelintConfig = !!stylelint;
+}

package/lib/resolver-sync.js

@@ -1 +1,21 @@
-import*as e from"fs";import s from"enhanced-resolve";let{CachedInputFileSystem:o,ResolverFactory:n}=s,m=n.createResolver({fileSystem:new o(e,4e3),conditionNames:["node"],extensions:[".js",".json",".node"],useSyncFileSystemCalls:!0,mainFields:["esm","module","main"]});export default m;
+import * as fs from 'fs';
+import enhancedResolve from 'enhanced-resolve';
+const { CachedInputFileSystem , ResolverFactory  } = enhancedResolve;
+const resolverSync = ResolverFactory.createResolver({
+    fileSystem: new CachedInputFileSystem(fs, 4000),
+    conditionNames: [
+        'node'
+    ],
+    extensions: [
+        '.js',
+        '.json',
+        '.node'
+    ],
+    useSyncFileSystemCalls: true,
+    mainFields: [
+        'esm',
+        'module',
+        'main'
+    ]
+});
+export default resolverSync;

package/lib/routes.d.ts

@@ -0,0 +1 @@
+export declare const frameworkCacheDir: "~/node_modules/@moneko/react/.cache/" | "~/node_modules/@moneko/solid-js/.cache/";

package/lib/routes.js

@@ -0,0 +1,171 @@
+import { readdirSync, statSync, writeFile, readFileSync, existsSync, mkdirSync } from 'fs';
+import { join, relative } from 'path';
+import { watch } from 'chokidar';
+import { load } from 'js-yaml';
+import { PROGRAMPATH, APPTYPE, FRAMEWORK, DEV } from './process-env.js';
+import { resolveNodeModulesPath } from './utils.js';
+const frontmatterRegex = /^---\n([\s\S]+?)\n---\n/;
+function extractFrontmatter(md) {
+    const matches = md.match(frontmatterRegex);
+    return matches && matches[1] ? matches[1].trim() : null;
+}
+function extractCode(codeStr) {
+    const codes = {};
+    const regex = /```(.+?)\n([\s\S]*?)\n```/g;
+    let match;
+    while((match = regex.exec(codeStr)) !== null){
+        const [, language = 'jsx', source] = match;
+        const lang = language.split(' ').pop() || 'jsx';
+        codes[lang] = source.trim();
+    }
+    return Object.keys(codes).length ? codes : {
+        jsx: codeStr
+    };
+}
+function getTree(directory, option) {
+    const { regex , alia , base =directory , outputSource  } = option;
+    const files = readdirSync(directory);
+    return files.reduce((tree, file)=>{
+        const filePath = join(directory, file);
+        const stats = statSync(filePath);
+        if (stats.isDirectory()) {
+            const children = getTree(filePath, {
+                ...option,
+                base
+            });
+            if (children.length > 0) {
+                const item = {};
+                const baseItem = {
+                    path: file,
+                    key: relative(base, filePath)
+                };
+                if (outputSource) {
+                    Object.assign(item, {
+                        children
+                    });
+                } else {
+                    const frist = children.splice(0, 1)[0];
+                    if (children.length) {
+                        Object.assign(item, {
+                            children: [
+                                {
+                                    ...frist,
+                                    path: '/',
+                                    key: baseItem.key
+                                },
+                                ...children
+                            ]
+                        });
+                    } else {
+                        Object.assign(item, frist);
+                    }
+                }
+                tree.push(Object.assign(item, baseItem));
+            }
+        } else if (regex.test(filePath)) {
+            const source = readFileSync(filePath, {
+                encoding: 'utf-8'
+            });
+            const frontmatter = extractFrontmatter(source);
+            const meta = frontmatter ? load(frontmatter) : {};
+            const reslove = relative(base, filePath);
+            tree.push(Object.assign({
+                path: file,
+                key: reslove,
+                meta: {
+                    ...meta
+                }
+            }, alia && {
+                element: `rr(() => import(/* webpackChunkName: '${reslove}' */'${join(alia, reslove)}'))rr`
+            }, outputSource && {
+                codes: extractCode(source.replace(frontmatterRegex, '').replace(/^\n+|\n+$/g, ''))
+            }));
+        }
+        return tree;
+    }, []);
+}
+const compPath = join(PROGRAMPATH, './components');
+export const frameworkCacheDir = resolveNodeModulesPath(`@moneko/${FRAMEWORK}/.cache/`);
+let genLibRouteTimer;
+function fallback(err) {
+    if (err) {
+        throw err;
+    }
+}
+function generatorLibraryRouter() {
+    if (genLibRouteTimer) {
+        clearTimeout(genLibRouteTimer);
+    }
+    genLibRouteTimer = setTimeout(()=>{
+        let replaceStr = 'lazy($1)';
+        let prefixStr = `import { lazy } from "${FRAMEWORK}";`;
+        if (![
+            'react',
+            'solid-js'
+        ].includes(FRAMEWORK)) {
+            replaceStr = '$1';
+            prefixStr = '';
+        }
+        const tree = JSON.stringify(getTree(compPath, {
+            regex: /README\.mdx?$/,
+            alia: '@pkg'
+        })).replace(/"rr\((.+?)\)rr"/g, replaceStr);
+        if (!existsSync(frameworkCacheDir)) {
+            mkdirSync(frameworkCacheDir);
+        }
+        writeFile(join(frameworkCacheDir, 'router.js'), `${prefixStr}export default ${tree}`, 'utf-8', fallback);
+    }, 100);
+}
+let genLibDemoTimer;
+function generatorLibraryDemo() {
+    if (genLibDemoTimer) {
+        clearTimeout(genLibDemoTimer);
+    }
+    genLibDemoTimer = setTimeout(()=>{
+        const tree = Object.fromEntries(getTree(compPath, {
+            regex: /\/examples\/(.+)\.mdx$/,
+            outputSource: true
+        }).map((item)=>[
+                item.key,
+                item.children?.[0].children?.map((e)=>({
+                        title: e.path,
+                        ...e.meta,
+                        codes: e.codes
+                    }))
+            ]));
+        if (!existsSync(frameworkCacheDir)) {
+            mkdirSync(frameworkCacheDir);
+        }
+        writeFile(join(frameworkCacheDir, 'examples.js'), `export default ${JSON.stringify(tree)}`, 'utf-8', fallback);
+    }, 100);
+}
+function watchFiles(root, ignored, call) {
+    const ignoredRouter = (src, stats)=>{
+        if (stats) {
+            if (stats?.isDirectory()) {
+                return false;
+            }
+            return ignored.test(src);
+        }
+    };
+    const watcher = watch(root, {
+        ignored: ignoredRouter,
+        persistent: true
+    });
+    watcher.on('add', ()=>{
+        call();
+    }).on('change', ()=>{
+        call();
+    }).on('unlink', ()=>{
+        call();
+    });
+}
+if (APPTYPE === 'library') {
+    if (DEV) {
+        watchFiles(compPath, /(?<!README\.mdx?)$/, generatorLibraryRouter);
+        watchFiles(compPath, /(?<!\/examples\/(.+)\.mdx)$/, generatorLibraryDemo);
+    } else {
+        generatorLibraryRouter();
+        generatorLibraryDemo();
+    }
+}

package/lib/seo.js

@@ -1 +1,57 @@
-import{existsSync as t,mkdirSync as o,writeFile as e,readdirSync as r,statSync as s}from"fs";import{join as m}from"path";import{CONFIG as p}from"./common.js";import{APPTYPE as i,PROGRAMPATH as n}from"./process-env.js";import{resolveProgramPath as c}from"./utils.js";import{outputConfig as f}from"./webpack.common.js";export const seo=()=>{let{domain:a,nojekyll:u,path:l}=p.seo||{};if(!a)return;let h=l&&c(l)||f?.path||process.cwd(),j=t=>{if(t)throw t};t(h)||o(h),e(m(h,"CNAME"),a,"utf-8",j),e(m(h,"robots"),`Sitemap: https://${a}${p.routeBaseName}sitemap.txt`,"utf-8",j);let E="";"library"===i&&(E=(function t(o,e,m){let p=[],i=r(o);return i.forEach(function(r){if("static"===r)return!1;let i=o+"/"+r,c=s(i);c&&c.isDirectory()?p=p.concat(t(i,e,m)):i.endsWith("README.mdx")&&p.push("https://"+e+m+i.replace(n+"/components/","").replace("/README.mdx",""))}),p})(m(n,"./components"),a,p.routeBaseName).join("\n")),e(m(h,"sitemap.txt"),E,"utf-8",j),u&&e(m(h,".nojekyll"),"","utf-8",j)};
+import { existsSync, mkdirSync, writeFile, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { CONFIG } from './common.js';
+import { APPTYPE, PROGRAMPATH } from './process-env.js';
+import { resolveProgramPath } from './utils.js';
+import { outputConfig } from './webpack.common.js';
+function getLibDocsPages(dir, domain, basename) {
+    let results = [];
+    const list = readdirSync(dir);
+    list.forEach(function(_file) {
+        if (_file === 'static') {
+            return false;
+        }
+        const file = dir + '/' + _file;
+        const stat = statSync(file);
+        if (stat && stat.isDirectory()) {
+            results = results.concat(getLibDocsPages(file, domain, basename));
+        } else if (file.endsWith('README.mdx')) {
+            results.push('https://' + domain + basename + file.replace(PROGRAMPATH + '/components/', '').replace('/README.mdx', ''));
+        }
+    });
+    return results;
+}
+export const seo = ()=>{
+    const { domain , nojekyll , path  } = CONFIG.seo || {};
+    if (!domain) {
+        return;
+    }
+    const baseDir = path && resolveProgramPath(path) || outputConfig?.path || process.cwd();
+    const call = (err)=>{
+        if (err) {
+            throw err;
+        }
+    };
+    if (!existsSync(baseDir)) {
+        mkdirSync(baseDir);
+    }
+    writeFile(join(baseDir, 'CNAME'), domain, 'utf-8', call);
+    writeFile(join(baseDir, 'robots'), `Sitemap: https://${domain}${CONFIG.routeBaseName}sitemap.txt`, 'utf-8', call);
+    let sitemap = '';
+    switch(APPTYPE){
+        case 'library':
+            sitemap = getLibDocsPages(join(PROGRAMPATH, './components'), domain, CONFIG.routeBaseName).join('\n');
+            break;
+        case 'single-component':
+        case 'mobile':
+        case 'site':
+        case 'back-stage':
+        case 'single-spa':
+        default:
+            break;
+    }
+    writeFile(join(baseDir, 'sitemap.txt'), sitemap, 'utf-8', call);
+    if (nojekyll) {
+        writeFile(join(baseDir, '.nojekyll'), '', 'utf-8', call);
+    }
+};

package/lib/swcrc.js

@@ -1 +1,107 @@
-import{merge as e}from"webpack-merge";import{CONFIG as o}from"./common.js";import r from"./envFlags.js";import{FRAMEWORK as t,jsxImportSource as s}from"./process-env.js";let n={env:{targets:["last 2 version","> 0.5%","ie 11","not dead"],mode:"entry",coreJs:"3"}};export const swcMinifyOption={compress:{top_retain:[],keep_infinity:!0,global_defs:{"@alert":"console.log"},pure_funcs:["console.log","console.warn","console.error","console.info"],toplevel:!1,drop_console:!0,drop_debugger:!0,module:!1,ecma:2015,ie8:!1,keep_classnames:void 0,keep_fnames:!1},mangle:!0};export default((a=!1)=>{let c={module:{type:"es6",ignoreDynamic:!0,strict:!0,strictMode:!0,lazy:!0,noInterop:!0},jsc:{parser:{syntax:"typescript",decorators:!0,dynamicImport:!0,tsx:!0},loose:!0,target:"es2022",externalHelpers:!0,transform:{legacyDecorator:!0,decoratorMetadata:!0,react:{runtime:"automatic",throwIfNamespace:!0,useBuiltins:!0,refresh:"react"===t&&a,development:a,importSource:s},constModules:{globals:{"env-flags":r}},optimizer:{simplify:!1}},experimental:{plugins:[["swc-plugin-another-transform-imports",function(e){for(let o=0,r=Object.keys(e),t=r.length;o<t;o++)e[r[o]].transform=`${r[o]}/${e[r[o]].transform}`,e[r[o]].style&&(e[r[o]].style=`${r[o]}/${e[r[o]].style}`);return e}(o.importOnDemand||{})]]}},sourceMaps:!0,parseMap:!0},l=Object.assign(c,!a&&n);return o.swcrc&&(l=e(l,"function"==typeof o.swcrc?o.swcrc(a):o.swcrc)),l});
+import { merge } from 'webpack-merge';
+import { CONFIG } from './common.js';
+import envFlags from './envFlags.js';
+import { FRAMEWORK, jsxImportSource } from './process-env.js';
+const swcPolyfill = {
+    env: {
+        targets: [
+            'last 2 version',
+            '> 0.5%',
+            'ie 11',
+            'not dead'
+        ],
+        mode: 'entry',
+        coreJs: '3'
+    }
+};
+export const swcMinifyOption = {
+    compress: {
+        top_retain: [],
+        keep_infinity: true,
+        global_defs: {
+            '@alert': 'console.log'
+        },
+        pure_funcs: [
+            'console.log',
+            'console.warn',
+            'console.error',
+            'console.info'
+        ],
+        toplevel: false,
+        drop_console: true,
+        drop_debugger: true,
+        module: false,
+        ecma: 2015,
+        ie8: false,
+        keep_classnames: undefined,
+        keep_fnames: false
+    },
+    mangle: true
+};
+function transformConfigs(config) {
+    for(let i = 0, ks = Object.keys(config), l = ks.length; i < l; i++){
+        config[ks[i]].transform = `${ks[i]}/${config[ks[i]].transform}`;
+        if (config[ks[i]].style) {
+            config[ks[i]].style = `${ks[i]}/${config[ks[i]].style}`;
+        }
+    }
+    return config;
+}
+export default ((isDev = false)=>{
+    const swcOption = {
+        module: {
+            type: 'es6',
+            ignoreDynamic: true,
+            strict: true,
+            strictMode: true,
+            lazy: true,
+            noInterop: true
+        },
+        jsc: {
+            parser: {
+                syntax: 'typescript',
+                decorators: true,
+                dynamicImport: true,
+                tsx: true
+            },
+            loose: true,
+            target: 'es2022',
+            externalHelpers: true,
+            transform: {
+                legacyDecorator: true,
+                decoratorMetadata: true,
+                react: {
+                    runtime: 'automatic',
+                    throwIfNamespace: true,
+                    useBuiltins: true,
+                    refresh: FRAMEWORK === 'react' && isDev,
+                    development: isDev,
+                    importSource: jsxImportSource
+                },
+                constModules: {
+                    globals: {
+                        'env-flags': envFlags
+                    }
+                },
+                optimizer: {
+                    simplify: false
+                }
+            },
+            experimental: {
+                plugins: [
+                    [
+                        'swc-plugin-another-transform-imports',
+                        transformConfigs(CONFIG.importOnDemand || {})
+                    ]
+                ]
+            }
+        },
+        sourceMaps: true,
+        parseMap: true
+    };
+    let swcrc = Object.assign(swcOption, !isDev && swcPolyfill);
+    if (CONFIG.swcrc) {
+        swcrc = merge(swcrc, typeof CONFIG.swcrc === 'function' ? CONFIG.swcrc(isDev) : CONFIG.swcrc);
+    }
+    return swcrc;
+});

package/lib/tsloader.config.js

@@ -1 +1,25 @@
-import t from"fs";import r from"ts-import-plugin";import o from"webpack-merge";import{CONFIG as e}from"./common.js";import{isFunction as m,resolveProgramPath as s,readConf as a}from"./utils.js";let i=[];Array.isArray(e.importOnDemand)&&Object.assign(i,e.importOnDemand.map(t=>r(t)));let n=[...i],p={transpileOnly:!0,getCustomTransformers:()=>({before:n})};try{let r=s("tsloader.config.ts");t.accessSync(r,t.constants.R_OK);let e=(await a(r,"tsloader.config")).default;p=o(p,m(e)?e(process):e)}catch(t){}export default p;
+import fs from 'fs';
+import transformerFactory from 'ts-import-plugin';
+import merge from 'webpack-merge';
+import { CONFIG } from './common.js';
+import { isFunction, resolveProgramPath, readConf } from './utils.js';
+const importOnDemand = [];
+if (Array.isArray(CONFIG.importOnDemand)) {
+    Object.assign(importOnDemand, CONFIG.importOnDemand.map((item)=>transformerFactory(item)));
+}
+const beforeTransformers = [
+    ...importOnDemand
+];
+let tsLoaderConfig = {
+    transpileOnly: true,
+    getCustomTransformers: ()=>({
+            before: beforeTransformers
+        })
+};
+try {
+    const customTsloaderConfigPath = resolveProgramPath('tsloader.config.ts');
+    fs.accessSync(customTsloaderConfigPath, fs.constants.R_OK);
+    const customTsloaderConfig = (await readConf(customTsloaderConfigPath, 'tsloader.config')).default;
+    tsLoaderConfig = merge(tsLoaderConfig, isFunction(customTsloaderConfig) ? customTsloaderConfig(process) : customTsloaderConfig);
+} catch (error) {}
+export default tsLoaderConfig;