ko 6.5.12 → 6.6.0-beta.1

package/lib/actions/build.d.ts

@@ -0,0 +1,12 @@
+import webpack from 'webpack';
+import Service from '../core/service';
+import { ActionFactory } from './factory';
+import { ICliOptions } from '../types';
+declare class Build extends ActionFactory {
+    private webpackConfig;
+    constructor(service: Service);
+    protected generateConfig(): Promise<webpack.Configuration>;
+    registerCommand(): void;
+    protected action(cliOpts: ICliOptions): Promise<void>;
+}
+export default Build;

package/lib/actions/dev.d.ts

@@ -0,0 +1,15 @@
+import Webpack from 'webpack';
+import Service from '../core/service';
+import ActionFactory from './factory';
+import { ICliOptions } from '../types';
+declare class Dev extends ActionFactory {
+    private webpackConfig;
+    constructor(service: Service);
+    private get devServerConfig();
+    protected generateConfig(): Promise<Webpack.Configuration>;
+    registerCommand(): void;
+    private changePort;
+    private checkPort;
+    protected action(cliOpts: ICliOptions): Promise<void>;
+}
+export default Dev;

package/lib/actions/dev.js

@@ -29,7 +29,11 @@ class Dev extends factory_1.default {
             setupExitSignals: false,
             allowedHosts: 'all',
             client: {
-                overlay: false,
+                overlay: {
+                    errors: true,
+                    warnings: false,
+                    runtimeErrors: true,
+                },
             },
             historyApiFallback,
         };

package/lib/actions/factory.d.ts

@@ -0,0 +1,12 @@
+import Service from '../core/service';
+export declare abstract class ActionFactory {
+    protected service: Service;
+    protected abstract generateConfig(opts: any): any;
+    protected abstract registerCommand(): void;
+    protected abstract action(...args: any[]): void;
+    protected constructor(service: Service);
+    protected successStdout(...logs: string[]): void;
+    protected warningStdout(...logs: string[]): void;
+    protected errorStdout(...logs: string[]): void;
+}
+export default ActionFactory;

package/lib/actions/lints.d.ts

@@ -0,0 +1,11 @@
+import { ActionFactory } from './factory';
+import { IKeys, IOpts as ILintOpts } from 'ko-lints';
+import Service from '../core/service';
+declare class LintFactory extends ActionFactory {
+    private name;
+    constructor(service: Service, name: IKeys);
+    generateConfig(): {};
+    registerCommand(): void;
+    protected action(patterns: string | string[], cliOpts: ILintOpts): Promise<void>;
+}
+export default LintFactory;

package/lib/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node --max_old_space_size=4096
+export {};

package/lib/core/commander.d.ts

@@ -0,0 +1,29 @@
+import { program, Command } from 'commander';
+type RegisterOptions = {
+    flags: string;
+    description: string;
+    defaultValue?: string | boolean;
+};
+type CMDProperties = {
+    description: string;
+    options?: RegisterOptions[];
+    args?: {
+        flags: string;
+        description: string;
+    }[];
+    action?: ActionFn;
+};
+type ActionFn = Parameters<typeof program.action>[0];
+declare class Commander {
+    private STATE;
+    program: Command;
+    private pkg;
+    private cmdSet;
+    constructor();
+    registerCommand({ name, description, args, options, }: CMDProperties & {
+        name: string;
+    }): void;
+    bindAction(name: string, fn: ActionFn): void;
+    parse(): void;
+}
+export default Commander;

package/lib/core/config.d.ts

@@ -0,0 +1,15 @@
+import { IOptions, ICliOptions } from '../types';
+declare class Config {
+    private cwd;
+    private origin;
+    private current;
+    private path;
+    cliOpts: Partial<ICliOptions>;
+    constructor();
+    private get isDevOrBuildCommand();
+    private getConfigPath;
+    generate(): IOptions;
+    freezeWithOpts(cliOpts: Partial<ICliOptions>): Readonly<Record<string, any> & Partial<ICliOptions>>;
+    get default(): Partial<IOptions>;
+}
+export default Config;

package/lib/core/hooks.d.ts

@@ -0,0 +1,12 @@
+import { HOOK_KEY_SET, HookOptions } from '../types';
+declare class Hooks {
+    private hooks;
+    hookKeySet: typeof HOOK_KEY_SET;
+    constructor();
+    register({ key, action, opts }: HookOptions): void;
+    apply(opts: {
+        key: string;
+        context?: any;
+    }): Promise<any>;
+}
+export default Hooks;

package/lib/core/service.d.ts

@@ -0,0 +1,12 @@
+import Commander from './commander';
+import Hooks from './hooks';
+import { IOptions, ICliOptions } from '../types';
+declare class Service extends Hooks {
+    config: IOptions;
+    cliOpts: Partial<ICliOptions>;
+    commander: Commander;
+    constructor();
+    freezeCliOptsWith(cliOpts: Partial<ICliOptions>): void;
+    run(): void;
+}
+export default Service;

package/lib/types.d.ts

@@ -0,0 +1,139 @@
+import { Pattern } from 'copy-webpack-plugin';
+import { Plugin } from 'postcss';
+import { IKeys, IOpts } from 'ko-lints';
+import { IOpts as AutoPolyfillsWebpackPluginOptions } from '@dtinsight/auto-polyfills-webpack-plugin';
+export type IOptions = {
+    /**
+     * The current working directory.
+     * @param {string}
+     */
+    cwd: string;
+    /**
+     * An object mapping module names to file paths or directories.
+     * @param {Record<string, string>}
+     */
+    alias?: Record<string, string>;
+    /**
+     * An array of patterns specifying files to copy to the output directory.
+     * @param {Pattern[]}
+     */
+    copy?: Pattern[];
+    /**
+     * The entry point of the application.
+     * @param {string}
+     */
+    entry?: string;
+    /**
+     * The path to the output directory.
+     * @param {string}
+     */
+    outputPath?: string;
+    /**
+     * The public path of the application.
+     * @param {string}
+     */
+    publicPath?: string;
+    /**
+     * Whether to append a hash to the output file name for cache busting.
+     * @param {boolean}
+     */
+    hash?: boolean;
+    /**
+     * An object mapping module names to global variables.
+     * @param {Record<string, string>}
+     */
+    externals?: Record<string, string>;
+    /**
+     * An array of plugin configurations.
+     * @param {HookOptions[]}
+     */
+    plugins?: HookOptions[];
+    /**
+     * The path to the HTML template to use for the application.
+     * @param {string}
+     */
+    htmlTemplate?: string;
+    htmlChunks?: 'all' | string[];
+    /**
+     * Whether to enable the bundle analyzer plugin.
+     * @param {boolean}
+     */
+    analyzer?: boolean;
+    /**
+     * An array of additional PostCSS plugins to use.
+     * @param {Plugin[]}
+     */
+    extraPostCSSPlugins?: Plugin[];
+    /**
+     * Options to pass to the Less compiler.
+     * @param {*}
+     */
+    lessOptions?: any;
+    /**
+     * A function to dynamically resolve module requests.
+     * @param {Function}
+     */
+    dynamicResolve?: <T extends any>(request: T) => T;
+    /**
+     * Whether to enable the auto-polyfills plugin, or an options object for the plugin.
+     * @param {string}
+     */
+    autoPolyfills: boolean | AutoPolyfillsWebpackPluginOptions;
+    /**
+     * Options for the development server.
+     * @param {{proxy?: Record<string, any>, host: string, port: number, staticPath?: string, historyApiFallback?: any, compilationSuccessInfo?: { messages: string[]; notes?: string[] }}}
+     */
+    serve: {
+        proxy?: Record<string, any>;
+        host: string;
+        port: number;
+        staticPath?: string;
+        historyApiFallback?: any;
+        compilationSuccessInfo?: {
+            messages: string[];
+            notes?: string[];
+        };
+    };
+    /**
+     * Experimental features to enable.
+     * @param {{speedUp?: boolean, minimizer?: boolean, disableLazyImports?: boolean, enableCssModule?: boolean, compress?: any}}
+     */
+    experiment?: {
+        speedUp?: boolean;
+        minimizer?: boolean;
+        disableLazyImports?: boolean;
+        enableCssModule?: boolean;
+        compress?: any;
+    };
+    /**
+     * Options for the linter plugins.
+     * @param {Record<IKeys, Omit<IOpts, 'write'>>}
+     */
+    lints?: Record<IKeys, Omit<IOpts, 'write'>>;
+};
+export type ICliOptions = {
+    hash?: boolean;
+    analyzer?: boolean;
+};
+export type IWebpackOptions = IOptions & {
+    isProd: boolean;
+} & ICliOptions;
+export type HookItem = {
+    name: string;
+    fn: Function;
+    stage?: number;
+    before?: string;
+};
+export declare enum ACTION {
+    ADD = "add",
+    UPDATE = "update"
+}
+export declare enum HOOK_KEY_SET {
+    WEBPACK_PLUGIN = "WebpackPlugin",
+    MODIFY_WEBPACK = "ModifyWebpack"
+}
+export type HookOptions = {
+    key: string;
+    action: ACTION;
+    opts: HookItem;
+};

package/lib/utils/index.d.ts

@@ -0,0 +1,3 @@
+export declare function getCacheIdentifier(env: string, pkgs: string[]): string;
+export declare function getResolvePath(name: string): string;
+export { default as assert } from 'assert';

package/lib/webpack/custom-plugins/purge-cache-webpack-plugin/index.d.ts

@@ -0,0 +1,7 @@
+import { Compiler } from 'webpack';
+declare class PurgeCacheWebpackPlugin {
+    WEBPACK_PLUGIN_NAME: string;
+    purgeCacheFiles(directory: string, maxAge: number, callback: (errors?: Error[]) => void): void;
+    apply(compiler: Compiler): void;
+}
+export default PurgeCacheWebpackPlugin;

package/lib/webpack/custom-plugins/purge-cache-webpack-plugin/index.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+class PurgeCacheWebpackPlugin {
+    constructor() {
+        this.WEBPACK_PLUGIN_NAME = 'PurgeCacheWebpackPlugin';
+    }
+    purgeCacheFiles(directory, maxAge, callback) {
+        promises_1.default.readdir(directory)
+            .then(files => {
+            const expiredPacks = [];
+            if (files.length === 0)
+                return callback();
+            for (const file of files) {
+                const pack = new Promise((resolve, reject) => {
+                    const filePath = path_1.default.join(directory, file);
+                    promises_1.default.stat(filePath)
+                        .then(stats => {
+                        if (stats.mtime.getTime() + maxAge < Date.now()) {
+                            promises_1.default.unlink(filePath)
+                                .then(() => {
+                                resolve(true);
+                            })
+                                .catch(err => reject(err));
+                        }
+                        else {
+                            resolve(true);
+                        }
+                    })
+                        .catch(err => reject(err));
+                });
+                expiredPacks.push(pack);
+            }
+            Promise.allSettled(expiredPacks).then(results => {
+                const errors = results
+                    .filter(result => result.status === 'rejected')
+                    .map((result) => result.reason);
+                callback(errors);
+            });
+        })
+            .catch(err => {
+            callback([err]);
+        });
+    }
+    apply(compiler) {
+        compiler.hooks.done.tapAsync({ name: this.WEBPACK_PLUGIN_NAME }, (_, callback) => {
+            const { type, maxAge, cacheLocation } = compiler.options.cache;
+            if (type === 'filesystem') {
+                const logger = compiler.getInfrastructureLogger(this.WEBPACK_PLUGIN_NAME);
+                this.purgeCacheFiles(cacheLocation, maxAge, errors => {
+                    if (errors?.length) {
+                        errors.forEach(err => logger.warn(err.message));
+                    }
+                    else {
+                        logger.info(`purge expired cache files completed`);
+                    }
+                    callback();
+                });
+            }
+            else {
+                callback();
+            }
+        });
+    }
+}
+exports.default = PurgeCacheWebpackPlugin;

package/lib/webpack/index.d.ts

@@ -0,0 +1,14 @@
+import { Configuration, FileCacheOptions } from 'webpack';
+import Service from '../core/service';
+declare class WebpackConfig {
+    private extensions;
+    private opts;
+    private env;
+    constructor(service: Service);
+    merge(...opts: Configuration[]): Configuration;
+    get cache(): FileCacheOptions;
+    get projectVersion(): string;
+    get base(): Configuration;
+    get isProd(): boolean;
+}
+export default WebpackConfig;

package/lib/webpack/index.js

@@ -43,6 +43,7 @@ class WebpackConfig {
         };
         if (type === 'filesystem') {
             cache.version = this.projectVersion;
+            cache.maxAge = 7 * 24 * 3600000;
         }
         else {
             cache.maxGenerations = 1;

package/lib/webpack/loaders/asset.d.ts

@@ -0,0 +1,8 @@
+declare const assetModules: {
+    test: RegExp;
+    type: string;
+    generator: {
+        filename: string;
+    };
+}[];
+export default assetModules;

package/lib/webpack/loaders/babel/index.d.ts

@@ -0,0 +1,50 @@
+import { IWebpackOptions } from '../../../types';
+declare class BabelLoader {
+    private BABEL_LOADER;
+    private opts;
+    private speedUp;
+    constructor(opts: IWebpackOptions);
+    get config(): {
+        loader: string;
+        options: {
+            presets: (string | {
+                useAbsoluteRuntime: boolean;
+            })[][];
+            plugins: ((string | {
+                libraryName: string;
+                libraryDirectory: string;
+                style: string;
+            })[] | (string | {
+                libraryName: string;
+                libraryDirectory: string;
+                camel2DashComponentName: string;
+            })[])[];
+            babelrc: boolean;
+            configFile: boolean;
+            cacheIdentifier: string;
+            cacheDirectory: boolean;
+            cacheCompression: boolean;
+            compact: boolean;
+        };
+    };
+    get treasurePluginConfig(): ((string | {
+        libraryName: string;
+        libraryDirectory: string;
+        style: string;
+    })[] | (string | {
+        libraryName: string;
+        libraryDirectory: string;
+        camel2DashComponentName: string;
+    })[])[];
+    get plugins(): ((string | {
+        libraryName: string;
+        libraryDirectory: string;
+        style: string;
+    })[] | (string | {
+        libraryName: string;
+        libraryDirectory: string;
+        camel2DashComponentName: string;
+    })[])[];
+    get cacheIdentifier(): string;
+}
+export default BabelLoader;

package/lib/webpack/loaders/index.d.ts

@@ -0,0 +1,71 @@
+import { IWebpackOptions } from '../../types';
+declare const loaders: (opts: IWebpackOptions) => (false | {
+    test: RegExp;
+    type: string;
+    generator: {
+        filename: string;
+    };
+} | {
+    test: RegExp;
+    use: {
+        loader: string;
+    }[];
+    exclude?: undefined;
+} | {
+    test: RegExp;
+    exclude: (input: string) => boolean;
+    use: {
+        loader: string;
+    }[];
+} | {
+    test: RegExp;
+    loader: string;
+    include: (input: string) => boolean;
+    options: {
+        inline: string;
+    };
+    use?: undefined;
+} | {
+    test: RegExp;
+    include: (input: string) => boolean;
+    use: ({
+        loader: string;
+        options: {
+            presets: (string | {
+                useAbsoluteRuntime: boolean;
+            })[][];
+            plugins: ((string | {
+                libraryName: string;
+                libraryDirectory: string;
+                style: string;
+            })[] | (string | {
+                libraryName: string;
+                libraryDirectory: string;
+                camel2DashComponentName: string;
+            })[])[];
+            babelrc: boolean;
+            configFile: boolean;
+            cacheIdentifier: string;
+            cacheDirectory: boolean;
+            cacheCompression: boolean;
+            compact: boolean;
+        };
+    } | {
+        loader: string;
+        options: {
+            name: string;
+            loader?: undefined;
+            target?: undefined;
+        };
+    } | {
+        loader: string;
+        options: {
+            loader: string;
+            target: string;
+            name?: undefined;
+        };
+    })[];
+    loader?: undefined;
+    options?: undefined;
+} | undefined)[];
+export default loaders;

package/lib/webpack/loaders/script.d.ts

@@ -0,0 +1,61 @@
+import { IWebpackOptions } from '../../types';
+declare class Script {
+    private THREAD_LOADER;
+    private WORKER_LOADER;
+    private ESBUILD_LOADER;
+    private BABEL_LOADER;
+    private opts;
+    constructor(opts: IWebpackOptions);
+    get config(): ({
+        test: RegExp;
+        loader: string;
+        include: (input: string) => boolean;
+        options: {
+            inline: string;
+        };
+        use?: undefined;
+    } | {
+        test: RegExp;
+        include: (input: string) => boolean;
+        use: ({
+            loader: string;
+            options: {
+                presets: (string | {
+                    useAbsoluteRuntime: boolean;
+                })[][];
+                plugins: ((string | {
+                    libraryName: string;
+                    libraryDirectory: string;
+                    style: string;
+                })[] | (string | {
+                    libraryName: string;
+                    libraryDirectory: string;
+                    camel2DashComponentName: string;
+                })[])[];
+                babelrc: boolean;
+                configFile: boolean;
+                cacheIdentifier: string;
+                cacheDirectory: boolean;
+                cacheCompression: boolean;
+                compact: boolean;
+            };
+        } | {
+            loader: string;
+            options: {
+                name: string;
+                loader?: undefined;
+                target?: undefined;
+            };
+        } | {
+            loader: string;
+            options: {
+                loader: string;
+                target: string;
+                name?: undefined;
+            };
+        })[];
+        loader?: undefined;
+        options?: undefined;
+    })[];
+}
+export default Script;

package/lib/webpack/loaders/style.d.ts

@@ -0,0 +1,72 @@
+import { IWebpackOptions } from '../../types';
+declare class Style {
+    private STYLE_LOADER;
+    private CSS_LOADER;
+    private SASS_LOADER;
+    private LESS_LOADER;
+    private POSTCSS_LOADER;
+    private CSS_MODULE_FILE_SUFFIX_REGEX;
+    private opts;
+    constructor(opts: IWebpackOptions);
+    get config(): (false | {
+        test: RegExp;
+        use: {
+            loader: string;
+        }[];
+        exclude?: undefined;
+    } | {
+        test: RegExp;
+        exclude: (input: string) => boolean;
+        use: {
+            loader: string;
+        }[];
+    } | undefined)[];
+    get sassCssModuleConfig(): {
+        test: RegExp;
+        use: ({
+            loader: string;
+        } | {
+            loader: string;
+            options: {
+                esModule: boolean;
+                modules: {
+                    namedExport: boolean;
+                    localIdentName: string;
+                };
+            };
+        })[];
+    };
+    get styleLoader(): {
+        loader: string;
+    };
+    get cssLoader(): {
+        loader: string;
+        options: {
+            sourceMap: boolean;
+        };
+    };
+    get sassLoader(): {
+        loader: string;
+        options: {
+            sourceMap: boolean;
+        };
+    };
+    get lessLoader(): {
+        loader: string;
+        options: {
+            sourceMap: boolean;
+            lessOptions: any;
+        };
+    };
+    get postCSSLoader(): {
+        loader: string;
+        options: {
+            sourceMap: boolean;
+            postcssOptions: {
+                plugins: any[];
+            };
+        };
+    };
+    get postCSSPlugins(): any[];
+}
+export default Style;

package/lib/webpack/plugins.d.ts

@@ -0,0 +1,3 @@
+import { IWebpackOptions } from '../types';
+declare function getPlugins(opts: IWebpackOptions): any[];
+export default getPlugins;

package/lib/webpack/plugins.js

@@ -14,7 +14,7 @@ const html_webpack_plugin_1 = __importDefault(require("html-webpack-plugin"));
 const webpack_bundle_analyzer_1 = require("webpack-bundle-analyzer");
 const auto_polyfills_webpack_plugin_1 = __importDefault(require("@dtinsight/auto-polyfills-webpack-plugin"));
 const friendly_errors_webpack_plugin_1 = __importDefault(require("@nuxt/friendly-errors-webpack-plugin"));
-const error_overlay_webpack_plugin_1 = __importDefault(require("error-overlay-webpack-plugin"));
+const purge_cache_webpack_plugin_1 = __importDefault(require("./custom-plugins/purge-cache-webpack-plugin"));
 function getPlugins(opts) {
     const { isProd, htmlTemplate, htmlChunks, copy, analyzer, autoPolyfills, serve: { host, port, compilationSuccessInfo }, } = opts;
     const htmlOptions = {
@@ -92,7 +92,7 @@ function getPlugins(opts) {
                     notes: [],
                 },
             }),
-        !isProd && new error_overlay_webpack_plugin_1.default(),
+        !isProd && new purge_cache_webpack_plugin_1.default(),
         isProd &&
             autoPolyfills &&
             (typeof autoPolyfills === 'boolean'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ko",
-  "version": "6.5.12",
+  "version": "6.6.0-beta.1",
   "description": "build & lint library",
   "keywords": [
     "ko",
@@ -34,16 +34,22 @@
   "files": [
     "lib/*"
   ],
+  "scripts": {
+    "prepublishOnly": "rm -rf lib && tsc",
+    "debug": "tsc -w --sourceMap",
+    "test": "jest",
+    "build": "tsc"
+  },
   "dependencies": {
     "@babel/core": "^7.18.0",
-    "@dtinsight/auto-polyfills-webpack-plugin": "2.0.0",
+    "@dtinsight/auto-polyfills-webpack-plugin": "workspace:2.0.0",
     "@nuxt/friendly-errors-webpack-plugin": "^2.5.2",
     "@parcel/css": "^1.12.2",
     "@pmmmwh/react-refresh-webpack-plugin": "^0.5.7",
     "autoprefixer": "^10.4.7",
     "babel-loader": "^8.2.5",
     "babel-plugin-treasure": "^0.9.0",
-    "babel-preset-ko-app": "^1.0.0",
+    "babel-preset-ko-app": "workspace:^1.0.0",
     "buffer": "^6.0.3",
     "case-sensitive-paths-webpack-plugin": "^2.4.0",
     "chalk": "^4.1.2",
@@ -54,12 +60,11 @@
     "css-loader": "^6.7.1",
     "css-minimizer-webpack-plugin": "^4.0.0",
     "detect-port": "^1.3.0",
-    "dynamic-resolve-webpack-plugin": "^2.0.0",
-    "error-overlay-webpack-plugin": "^1.1.1",
+    "dynamic-resolve-webpack-plugin": "workspace:^2.0.0",
     "esbuild-loader": "^2.19.0",
     "html-webpack-plugin": "^5.5.0",
     "inquirer": "^8.2.2",
-    "ko-lints": "^4.0.0",
+    "ko-lints": "workspace:^4.0.0",
     "less": "^3.13.1",
     "less-loader": "^9.1.0",
     "lodash": "^4.17.21",
@@ -80,7 +85,7 @@
     "thread-loader": "^3.0.4",
     "webpack": "^5.72.1",
     "webpack-bundle-analyzer": "^4.5.0",
-    "webpack-dev-server": "4.9.0",
+    "webpack-dev-server": "4.14.0",
     "webpackbar": "^5.0.2",
     "worker-loader": "^3.0.8"
   },
@@ -97,11 +102,5 @@
   },
   "engines": {
     "node": ">=14"
-  },
-  "scripts": {
-    "debug": "tsc -w --sourceMap",
-    "test": "jest",
-    "build": "tsc"
-  },
-  "readme": "# ko\nEnglish | [简体中文](./README_CN.md)\n## Simple, yet powerful, tool for managing your react applications. \n\n<a href=\"https://www.npmjs.com/package/ko\"><img alt=\"NPM Status\" src=\"https://img.shields.io/npm/v/ko.svg?style=flat\"></a>\n\n## Features\n\n* Support building applications on top of **webpack v5** and **esbuild**\n* Customize ko to work exactly the way you need it for your applications \n* Built-in popular linting tools to lint your source code\n* Built-in support typescript\n\n## Installation\n\nYou can install ko using npm, yarn or pnpm:\n``` bash\nnpm install ko --save-dev\n# or\nyarn add ko --dev\n# or \npnpm add ko --save-dev\n```\n\n## Documents\n* [Introduction](https://dtstack.github.io/ko/zh-CN/docs/current/introduction)\n* [Getting Started](https://dtstack.github.io/ko/zh-CN/docs/current/getting-started)\n* [FAQ](https://dtstack.github.io/ko/zh-CN/docs/current/FAQ)\n\n## Contributing\n\nWe'd love to have your helping hand on `ko`! See [CONTRIBUTING](../../CONTRIBUTING.md) for more information on how to get started.\n\n## License\n\nCopyright © DTStack. All rights reserved.\n\nLicensed under the MIT license.\n"
-}
+  }
+}