dumi 2.3.0-beta.7 → 2.3.0-beta.8

package/dist/assetParsers/BaseParser.d.ts

@@ -0,0 +1,55 @@
+import type { AtomComponentAsset, AtomFunctionAsset } from 'dumi-assets-types';
+import { chokidar } from 'umi/plugin-utils';
+export interface IPatchFile {
+    event: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir';
+    fileName: string;
+}
+export interface IAtomAssetsParserResult {
+    components: Record<string, AtomComponentAsset>;
+    functions: Record<string, AtomFunctionAsset>;
+}
+/**
+ * The parsing and extraction of language metadata should be implemented separately
+ */
+export interface ILanguageMetaParser {
+    patch(file: IPatchFile): void;
+    parse(): Promise<IAtomAssetsParserResult>;
+    destroy(): Promise<void>;
+}
+export interface IHandleWatcherArgs {
+    patch: ILanguageMetaParser['patch'];
+    parse: () => void;
+    watchArgs: {
+        paths: string | string[];
+        options: chokidar.WatchOptions;
+    };
+}
+export interface IBaseAtomAssetsParserParams<T> {
+    entryFile: string;
+    resolveDir: string;
+    parser: T;
+    handleWatcher?: (watcher: chokidar.FSWatcher, params: IHandleWatcherArgs) => chokidar.FSWatcher;
+    watchOptions?: chokidar.WatchOptions;
+}
+export declare class BaseAtomAssetsParser<T extends ILanguageMetaParser = ILanguageMetaParser> {
+    private watchArgs;
+    private watcher;
+    private handleWatcher?;
+    private entryDir;
+    private resolveDir;
+    private readonly parser;
+    private isParsing;
+    private parseDeferrer;
+    private cbs;
+    constructor(opts: IBaseAtomAssetsParserParams<T>);
+    parse(): Promise<IAtomAssetsParserResult>;
+    watch(cb: (data: IAtomAssetsParserResult) => void): void;
+    unwatch(cb: (data: IAtomAssetsParserResult) => void): void;
+    patchWatchArgs(handler: (args: BaseAtomAssetsParser<T>['watchArgs']) => BaseAtomAssetsParser<T>['watchArgs']): void;
+    getWatchArgs(): {
+        paths: string | string[];
+        options: chokidar.WatchOptions;
+    };
+    destroyWorker(): Promise<void>;
+}
+export type IAtomAssetsParser = InstanceType<typeof BaseAtomAssetsParser>;

package/dist/assetParsers/BaseParser.js

@@ -0,0 +1,126 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/assetParsers/BaseParser.ts
+var BaseParser_exports = {};
+__export(BaseParser_exports, {
+  BaseAtomAssetsParser: () => BaseAtomAssetsParser
+});
+module.exports = __toCommonJS(BaseParser_exports);
+var import_path = __toESM(require("path"));
+var import_plugin_utils = require("umi/plugin-utils");
+var BaseAtomAssetsParser = class {
+  constructor(opts) {
+    this.watcher = null;
+    this.isParsing = false;
+    this.parseDeferrer = null;
+    this.cbs = [];
+    const { entryFile, resolveDir, watchOptions, parser, handleWatcher } = opts;
+    this.resolveDir = resolveDir;
+    const absEntryFile = import_path.default.resolve(resolveDir, entryFile);
+    this.entryDir = import_path.default.relative(opts.resolveDir, import_path.default.dirname(absEntryFile));
+    this.watchArgs = {
+      paths: this.entryDir,
+      options: {
+        cwd: this.resolveDir,
+        ignored: [
+          "**/.*",
+          "**/.*/**",
+          "**/_*",
+          "**/_*/**",
+          "**/*.{md,less,scss,sass,styl,css}"
+        ],
+        ignoreInitial: true,
+        ...watchOptions
+      }
+    };
+    this.handleWatcher = handleWatcher;
+    this.parser = parser;
+  }
+  async parse() {
+    if (!this.parseDeferrer) {
+      this.isParsing = true;
+      this.parseDeferrer = this.parser.parse().finally(() => {
+        this.isParsing = false;
+      });
+    }
+    return this.parseDeferrer;
+  }
+  watch(cb) {
+    this.cbs.push(cb);
+    if (!this.watcher && this.handleWatcher) {
+      const lazyParse = import_plugin_utils.lodash.debounce(() => {
+        this.parse().then((data) => this.cbs.forEach((cb2) => cb2(data))).catch((err) => {
+          import_plugin_utils.logger.error(err);
+        });
+      }, 100);
+      this.watcher = import_plugin_utils.chokidar.watch(
+        this.watchArgs.paths,
+        this.watchArgs.options
+      );
+      this.handleWatcher(this.watcher, {
+        parse: () => {
+          if (this.isParsing && this.parseDeferrer) {
+            this.parseDeferrer.finally(() => {
+              this.parseDeferrer = null;
+              lazyParse();
+            });
+          } else {
+            this.parseDeferrer = null;
+            lazyParse();
+          }
+        },
+        watchArgs: this.watchArgs,
+        patch: (file) => {
+          this.parser.patch(file);
+        }
+      });
+      lazyParse();
+    }
+  }
+  unwatch(cb) {
+    this.cbs.splice(this.cbs.indexOf(cb), 1);
+  }
+  patchWatchArgs(handler) {
+    this.watchArgs = handler(this.watchArgs);
+  }
+  getWatchArgs() {
+    return this.watchArgs;
+  }
+  async destroyWorker() {
+    if (this.parseDeferrer) {
+      await this.parseDeferrer;
+      this.parseDeferrer = null;
+    }
+    await this.parser.destroy();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseAtomAssetsParser
+});

package/dist/assetParsers/atom.d.ts

@@ -1,30 +1,21 @@
-import { AtomComponentAsset, AtomFunctionAsset } from 'dumi-assets-types';
-declare class AtomAssetsParser {
-    private entryDir;
-    private resolveDir;
-    private unresolvedFiles;
+import { BaseAtomAssetsParser, IAtomAssetsParserResult, ILanguageMetaParser, IPatchFile } from './BaseParser';
+interface ParserParams {
+    entryFile: string;
+    resolveDir: string;
+    resolveFilter?: ReactMetaParser['resolveFilter'];
+    unpkgHost?: string;
+    parseOptions?: object;
+}
+declare class ReactMetaParser implements ILanguageMetaParser {
     private parser;
-    private isParsing;
-    private parseDeferrer;
-    private watcher;
-    private cbs;
     private resolveFilter;
-    private watchArgs;
-    constructor(opts: {
-        entryFile: string;
-        resolveDir: string;
-        resolveFilter?: AtomAssetsParser['resolveFilter'];
-        unpkgHost?: string;
-        watch?: boolean;
-        parseOptions?: object;
-    });
-    parse(): Promise<{
-        components: Record<string, AtomComponentAsset>;
-        functions: Record<string, AtomFunctionAsset>;
-    }>;
-    watch(cb: AtomAssetsParser['cbs'][number]): void;
-    unwatch(cb: AtomAssetsParser['cbs'][number]): void;
-    patchWatchArgs(handler: (args: AtomAssetsParser['watchArgs']) => AtomAssetsParser['watchArgs']): void;
-    destroyWorker(): void;
+    private unresolvedFiles;
+    constructor(opts: ParserParams);
+    parse(): Promise<IAtomAssetsParserResult>;
+    destroy(): Promise<void>;
+    patch(file: IPatchFile): void;
+}
+declare class ReactAtomAssetsParser extends BaseAtomAssetsParser<ReactMetaParser> {
+    constructor(opts: ParserParams);
 }
-export default AtomAssetsParser;
+export default ReactAtomAssetsParser;

package/dist/assetParsers/atom.js

@@ -36,132 +36,106 @@ var import_utils = require("../utils");
 var import_parser = require("dumi-afx-deps/compiled/parser");
 var import_path = __toESM(require("path"));
 var import_plugin_utils = require("umi/plugin-utils");
+var import_BaseParser = require("./BaseParser");
 var MAX_PARSE_SIZE = 1024 * 512;
-var AtomAssetsParser = class {
+var ReactMetaParser = class {
   constructor(opts) {
     this.unresolvedFiles = [];
-    this.isParsing = false;
-    this.watcher = null;
-    this.cbs = [];
-    const absEntryFile = import_path.default.resolve(opts.resolveDir, opts.entryFile);
-    this.resolveDir = opts.resolveDir;
+    const { resolveDir, entryFile, parseOptions, unpkgHost } = opts;
+    const absEntryFile = import_path.default.resolve(resolveDir, entryFile);
     this.resolveFilter = opts.resolveFilter || (() => true);
-    this.entryDir = import_path.default.relative(opts.resolveDir, import_path.default.dirname(absEntryFile));
     this.parser = new import_parser.SchemaParser({
       entryPath: absEntryFile,
-      basePath: (0, import_utils.getProjectRoot)(opts.resolveDir),
-      unPkgHost: opts.unpkgHost ?? "https://unpkg.com",
+      basePath: (0, import_utils.getProjectRoot)(resolveDir),
+      unPkgHost: unpkgHost ?? "https://unpkg.com",
       mode: "worker",
       // @ts-ignore
-      parseOptions: opts.parseOptions
+      parseOptions
     });
-    this.watchArgs = {
-      paths: this.entryDir,
-      options: {
-        cwd: this.resolveDir,
-        ignored: [
-          "**/.*",
-          "**/.*/**",
-          "**/_*",
-          "**/_*/**",
-          "**/*.{md,less,scss,sass,styl,css}"
-        ],
-        ignoreInitial: true
-      }
-    };
   }
   async parse() {
-    if (!this.parseDeferrer || this.unresolvedFiles.length && !this.isParsing) {
-      this.isParsing = true;
-      this.parseDeferrer = (async () => {
-        await this.parser.patch(this.unresolvedFiles.splice(0));
-        const resolver = new import_parser.SchemaResolver(await this.parser.parse(), {
-          mode: "worker"
-        });
-        const result = {
-          components: {},
-          functions: {}
-        };
-        const fallbackProps = { type: "object", properties: {} };
-        const fallbackSignature = { arguments: [] };
-        const componentList = await resolver.componentList;
-        const functionList = await resolver.functionList;
-        for (const id of componentList) {
-          const needResolve = this.resolveFilter({
-            id,
-            type: "COMPONENT",
-            ids: componentList
-          });
-          let propsConfig = needResolve ? (await resolver.getComponent(id)).props : fallbackProps;
-          const size = Buffer.byteLength(JSON.stringify(propsConfig));
-          if (size > MAX_PARSE_SIZE) {
-            propsConfig = fallbackProps;
-            import_plugin_utils.logger.warn(
-              `Parsed component ${id} props size ${size} exceeds 512KB, skip it.`
-            );
-          }
-          result.components[id] = {
-            type: "COMPONENT",
-            id,
-            title: id,
-            propsConfig
-          };
-        }
-        for (const id of functionList) {
-          const needResolve = this.resolveFilter({
-            id,
-            type: "FUNCTION",
-            ids: functionList
-          });
-          let signature = needResolve ? (await resolver.getFunction(id)).signature : fallbackSignature;
-          const size = Buffer.byteLength(JSON.stringify(signature));
-          if (size > MAX_PARSE_SIZE) {
-            signature = fallbackSignature;
-            import_plugin_utils.logger.warn(
-              `Parsed function ${id} signature size ${size} exceeds 512KB, skip it.`
-            );
-          }
-          result.functions[id] = {
-            type: "FUNCTION",
-            id,
-            title: id,
-            signature
-          };
-        }
-        resolver.$$destroyWorker();
-        this.isParsing = false;
-        return result;
-      })();
+    await this.parser.patch(this.unresolvedFiles.splice(0));
+    const resolver = new import_parser.SchemaResolver(await this.parser.parse(), {
+      mode: "worker"
+    });
+    const result = {
+      components: {},
+      functions: {}
+    };
+    const fallbackProps = { type: "object", properties: {} };
+    const fallbackSignature = { arguments: [] };
+    const componentList = await resolver.componentList;
+    const functionList = await resolver.functionList;
+    for (const id of componentList) {
+      const needResolve = this.resolveFilter({
+        id,
+        type: "COMPONENT",
+        ids: componentList
+      });
+      let propsConfig = needResolve ? (await resolver.getComponent(id)).props : fallbackProps;
+      const size = Buffer.byteLength(JSON.stringify(propsConfig));
+      if (size > MAX_PARSE_SIZE) {
+        propsConfig = fallbackProps;
+        import_plugin_utils.logger.warn(
+          `Parsed component ${id} props size ${size} exceeds 512KB, skip it.`
+        );
+      }
+      result.components[id] = {
+        type: "COMPONENT",
+        id,
+        title: id,
+        propsConfig
+      };
     }
-    return this.parseDeferrer;
-  }
-  watch(cb) {
-    this.cbs.push(cb);
-    if (!this.watcher) {
-      const lazyParse = import_plugin_utils.lodash.debounce(() => {
-        this.parse().then((data) => this.cbs.forEach((cb2) => cb2(data)));
-      }, 100);
-      this.watcher = import_plugin_utils.chokidar.watch(this.watchArgs.paths, this.watchArgs.options).on("all", (ev, file) => {
-        if (["add", "change"].includes(ev) && /((?<!\.d)\.ts|\.(jsx?|tsx))$/.test(file)) {
-          this.unresolvedFiles.push(import_path.default.join(this.watchArgs.options.cwd, file));
-          lazyParse();
-        }
+    for (const id of functionList) {
+      const needResolve = this.resolveFilter({
+        id,
+        type: "FUNCTION",
+        ids: functionList
       });
-      lazyParse();
+      let signature = needResolve ? (await resolver.getFunction(id)).signature : fallbackSignature;
+      const size = Buffer.byteLength(JSON.stringify(signature));
+      if (size > MAX_PARSE_SIZE) {
+        signature = fallbackSignature;
+        import_plugin_utils.logger.warn(
+          `Parsed function ${id} signature size ${size} exceeds 512KB, skip it.`
+        );
+      }
+      result.functions[id] = {
+        type: "FUNCTION",
+        id,
+        title: id,
+        signature
+      };
     }
+    resolver.$$destroyWorker();
+    return result;
   }
-  unwatch(cb) {
-    this.cbs.splice(this.cbs.indexOf(cb), 1);
+  destroy() {
+    return this.parser.$$destroyWorker();
   }
-  patchWatchArgs(handler) {
-    this.watchArgs = handler(this.watchArgs);
+  patch(file) {
+    this.unresolvedFiles.push(file.fileName);
   }
-  destroyWorker() {
-    if (this.parseDeferrer) {
-      this.parseDeferrer.finally(() => this.parser.$$destroyWorker());
-    } else {
-      this.parser.$$destroyWorker();
-    }
+};
+var ReactAtomAssetsParser = class extends import_BaseParser.BaseAtomAssetsParser {
+  constructor(opts) {
+    super({
+      ...opts,
+      parser: new ReactMetaParser(opts),
+      handleWatcher: (watcher, { parse, patch, watchArgs }) => {
+        return watcher.on("all", (ev, file) => {
+          if (["add", "change"].includes(ev) && /((?<!\.d)\.ts|\.(jsx?|tsx))$/.test(file)) {
+            const cwd = watchArgs.options.cwd;
+            patch({
+              event: ev,
+              fileName: import_path.default.join(cwd, file)
+            });
+            parse();
+          }
+        });
+      }
+    });
   }
 };
-var atom_default = AtomAssetsParser;
+var atom_default = ReactAtomAssetsParser;

package/dist/assetParsers/block.d.ts

@@ -1,6 +1,7 @@
 import { parseCodeFrontmatter } from "../utils";
 import type { ExampleBlockAsset } from 'dumi-assets-types';
 import type { sync } from 'enhanced-resolve';
+import { IDumiTechStack } from '../types';
 export interface IParsedBlockAsset {
     asset: ExampleBlockAsset;
     /**
@@ -18,5 +19,6 @@ declare function parseBlockAsset(opts: {
     refAtomIds: string[];
     entryPointCode?: string;
     resolver: typeof sync;
+    techStack: IDumiTechStack;
 }): Promise<IParsedBlockAsset>;
 export default parseBlockAsset;

package/dist/assetParsers/block.js

@@ -38,12 +38,14 @@ var import_assert = __toESM(require("assert"));
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_plugin_utils = require("umi/plugin-utils");
+var import_constants = require("../constants");
 async function parseBlockAsset(opts) {
   const asset = {
     type: "BLOCK",
     id: opts.id,
     refAtomIds: opts.refAtomIds,
-    dependencies: {}
+    dependencies: {},
+    entry: ""
   };
   const result = {
     asset,
@@ -95,34 +97,45 @@ async function parseBlockAsset(opts) {
             };
           });
           builder.onLoad({ filter: /.*/ }, (args) => {
-            const ext = import_path.default.extname(args.path);
-            const isModule = [".js", ".jsx", ".ts", ".tsx"].includes(ext);
-            const isPlainText = [
-              ".css",
-              ".less",
-              ".sass",
-              ".scss",
-              ".styl",
-              ".json"
-            ].includes(ext);
+            let ext = import_path.default.extname(args.path);
+            const techStack = opts.techStack;
             const isEntryPoint = args.pluginData.kind === "entry-point";
             const filename = `${isEntryPoint ? "index" : (0, import_plugin_utils.winPath)(
               import_path.default.format({
                 ...import_path.default.parse(args.pluginData.source),
+                base: "",
                 ext: ""
               })
             )}${ext}`;
+            let entryPointCode = opts.entryPointCode;
+            let contents = void 0;
+            if (techStack.onBlockLoad) {
+              const result2 = techStack.onBlockLoad({
+                filename,
+                entryPointCode: entryPointCode ?? (entryPointCode = import_fs.default.readFileSync(
+                  args.path,
+                  "utf-8"
+                )),
+                ...args
+              });
+              if (result2) {
+                ext = `.${result2.type}`;
+                contents = result2.content;
+              }
+            }
+            let isModule = import_constants.DEFAULT_DEMO_MODULE_EXTENSIONS.includes(ext);
+            let isPlainText = import_constants.DEFAULT_DEMO_PLAIN_TEXT_EXTENSIONS.includes(ext);
             if (isModule || isPlainText) {
               asset.dependencies[filename] = {
                 type: "FILE",
                 value: opts.entryPointCode ?? import_fs.default.readFileSync(args.path, "utf-8")
               };
+              const file = asset.dependencies[filename];
               if (isEntryPoint) {
-                const { code, frontmatter } = (0, import_utils.parseCodeFrontmatter)(
-                  asset.dependencies[filename].value
-                );
+                const { code, frontmatter } = (0, import_utils.parseCodeFrontmatter)(file.value);
+                asset.entry = filename;
                 if (frontmatter) {
-                  asset.dependencies[filename].value = code;
+                  file.value = code;
                   result.frontmatter = frontmatter;
                   ["description", "title", "snapshot", "keywords"].forEach(
                     (key) => {
@@ -136,7 +149,7 @@ async function parseBlockAsset(opts) {
               }
               return {
                 // only continue to load for module files
-                contents: isModule ? asset.dependencies[filename].value : "",
+                contents: isModule ? contents ?? file.value : "",
                 loader: isModule ? ext.slice(1) : "text"
               };
             }

package/dist/assetParsers/utils.d.ts

@@ -0,0 +1,79 @@
+import { BaseAtomAssetsParser, IBaseAtomAssetsParserParams, ILanguageMetaParser } from './BaseParser';
+/**
+ * Only expose these methods to avoid all properties being proxied
+ * @param ClassConstructor The Class to be processed
+ * @param publicMethods accessible Class methods
+ * @returns processed Class
+ */
+export declare function createExposedClass<T extends {
+    new (...args: ConstructorParameters<T>): InstanceType<T>;
+}>(ClassConstructor: T, publicMethods?: string[]): {
+    new (...params: ConstructorParameters<T>): {};
+};
+/**
+ * Create Class that can execute across threads
+ * @param filename Child thread running script path
+ * @param ClassConstructor Class that require remote execution
+ * @param opts
+ * @returns Remote Class, all its methods are asynchronous
+ */
+export declare function createRemoteClass<T extends {
+    new (...args: ConstructorParameters<T>): InstanceType<T>;
+}>(filename: string, ClassConstructor: T, opts?: {
+    destroyMethod: string;
+    publicMethods?: string[];
+}): T;
+interface ICreateApiParserOptions<S, C> {
+    /**
+     * The full file name (absolute path) of the file where `parseWorker` is located
+     */
+    filename: string;
+    /**
+     * Parsing class working in worker_thead
+     */
+    worker: S;
+    /**
+     * Main thread side work, mainly to detect file changes
+     */
+    parseOptions?: C;
+}
+export interface IBaseApiParserOptions {
+    entryFile: string;
+    resolveDir: string;
+}
+/**
+ * Can be used to override apiParser
+ * @param options
+ * @returns A function that returns a Parser instance
+ * @example
+ * ```ts
+ * interface ParserOptions extends BaseApiParserOptions  {
+ *    // other props...
+ * }
+ * const Parser = createApiParser({
+ *    filename: __filename,
+ *    worker: (class {
+ *      constructor(opts: ParserOptions) {}
+ *      patch () {}
+ *      async parse () {
+ *        return {
+ *          components: {},
+ *          functions: {}
+ *        };
+ *      }
+ *      async destroy () {}
+ *    }),
+ *    parserOptions: {
+ *      handleWatcher(watcher, { parse, patch }) {
+ *        return watcher.on('all', (ev, file) => {
+ *          // You can perform patch and parse operations based on file changes.
+ *          // patch will transfer the corresponding file to the parseWorker,
+ *          // and parse will instruct the parseWorker to parse according to updated files.
+ *        });
+ *      },
+ *    },
+ * });
+ * ```
+ */
+export declare function createApiParser<P extends new (...args: ConstructorParameters<P>) => InstanceType<P> & ILanguageMetaParser>(options: ICreateApiParserOptions<P, Partial<IBaseAtomAssetsParserParams<P>>>): (...args: ConstructorParameters<P>) => BaseAtomAssetsParser<ILanguageMetaParser>;
+export {};