dumi 2.3.4 → 2.4.0-alpha.1

package/compiled/loader-runner/index.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+
+export declare interface ExtendedLoaderContext {
+  context: string | null;
+  loaderIndex: number;
+  loaders: Loader[];
+  resourcePath: string | undefined;
+  resourceQuery: string | undefined;
+  async: (() => (() => void) | undefined) | null;
+  callback: (() => void) | null;
+  cacheable: (flag: boolean) => void;
+  dependency: (file: string) => void;
+  addDependency: (file: string) => void;
+  addContextDependency: (context: string) => void;
+  getDependencies: () => string[];
+  getContextDependencies: () => string[];
+  clearDependencies: () => void;
+  resource: string;
+  request: string;
+  remainingRequest: string;
+  currentRequest: string;
+  previousRequest: string;
+  query: {
+      [key: string]: any;
+  } | string;
+  data: any;
+}
+
+export declare function getContext(resource: string): string;
+
+export declare interface Loader {
+  path: string;
+  query: string;
+  request: string;
+  options: any;
+  normal: null | ((request: string) => string);
+  pitch: null | ((request: string) => string);
+  raw: string;
+  data: any;
+  pitchExecuted: boolean;
+  normalExecuted: boolean;
+}
+
+export declare interface RunLoaderOption {
+  resource: string;
+  loaders: any[];
+  context: any;
+  readResource: (
+  filename: string,
+  callback: (err: NodeJS.ErrnoException | null, data: Buffer | null) => void,
+  ) => void;
+}
+
+export declare interface RunLoaderResult {
+  result?: Array<Buffer | null> | undefined;
+  resourceBuffer?: Buffer | null | undefined;
+  cacheable: boolean;
+  fileDependencies: string[];
+  contextDependencies: string[];
+}
+
+export declare function runLoaders(
+options: RunLoaderOption,
+callback: (err: NodeJS.ErrnoException | null, result: RunLoaderResult) => any,
+): void;
+
+export { }

package/compiled/loader-runner/index.js

@@ -0,0 +1,567 @@
+/******/ (function() { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 441:
+/***/ (function(module) {
+
+  "use strict";
+
+
+  class LoadingLoaderError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "LoaderRunnerError";
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+
+  module.exports = LoadingLoaderError;
+
+
+  /***/ }),
+
+  /***/ 713:
+  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
+
+  var LoaderLoadingError = __nccwpck_require__(441);
+  var url;
+
+  module.exports = function loadLoader(loader, callback) {
+    if(loader.type === "module") {
+      try {
+        if(url === undefined) url = __nccwpck_require__(310);
+        var loaderUrl = url.pathToFileURL(loader.path);
+        var modulePromise = eval("import(" + JSON.stringify(loaderUrl.toString()) + ")");
+        modulePromise.then(function(module) {
+          handleResult(loader, module, callback);
+        }, callback);
+        return;
+      } catch(e) {
+        callback(e);
+      }
+    } else {
+      try {
+        var module = require(loader.path);
+      } catch(e) {
+        // it is possible for node to choke on a require if the FD descriptor
+        // limit has been reached. give it a chance to recover.
+        if(e instanceof Error && e.code === "EMFILE") {
+          var retry = loadLoader.bind(null, loader, callback);
+          if(typeof setImmediate === "function") {
+            // node >= 0.9.0
+            return setImmediate(retry);
+          } else {
+            // node < 0.9.0
+            return process.nextTick(retry);
+          }
+        }
+        return callback(e);
+      }
+      return handleResult(loader, module, callback);
+    }
+  };
+
+  function handleResult(loader, module, callback) {
+    if(typeof module !== "function" && typeof module !== "object") {
+      return callback(new LoaderLoadingError(
+        "Module '" + loader.path + "' is not a loader (export function or es6 module)"
+      ));
+    }
+    loader.normal = typeof module === "function" ? module : module.default;
+    loader.pitch = module.pitch;
+    loader.raw = module.raw;
+    if(typeof loader.normal !== "function" && typeof loader.pitch !== "function") {
+      return callback(new LoaderLoadingError(
+        "Module '" + loader.path + "' is not a loader (must have normal or pitch function)"
+      ));
+    }
+    callback();
+  }
+
+
+  /***/ }),
+
+  /***/ 147:
+  /***/ (function(module) {
+
+  "use strict";
+  module.exports = require("fs");
+
+  /***/ }),
+
+  /***/ 310:
+  /***/ (function(module) {
+
+  "use strict";
+  module.exports = require("url");
+
+  /***/ })
+
+  /******/ 	});
+  /************************************************************************/
+  /******/ 	// The module cache
+  /******/ 	var __webpack_module_cache__ = {};
+  /******/ 	
+  /******/ 	// The require function
+  /******/ 	function __nccwpck_require__(moduleId) {
+  /******/ 		// Check if module is in cache
+  /******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+  /******/ 		if (cachedModule !== undefined) {
+  /******/ 			return cachedModule.exports;
+  /******/ 		}
+  /******/ 		// Create a new module (and put it into the cache)
+  /******/ 		var module = __webpack_module_cache__[moduleId] = {
+  /******/ 			// no module.id needed
+  /******/ 			// no module.loaded needed
+  /******/ 			exports: {}
+  /******/ 		};
+  /******/ 	
+  /******/ 		// Execute the module function
+  /******/ 		var threw = true;
+  /******/ 		try {
+  /******/ 			__webpack_modules__[moduleId](module, module.exports, __nccwpck_require__);
+  /******/ 			threw = false;
+  /******/ 		} finally {
+  /******/ 			if(threw) delete __webpack_module_cache__[moduleId];
+  /******/ 		}
+  /******/ 	
+  /******/ 		// Return the exports of the module
+  /******/ 		return module.exports;
+  /******/ 	}
+  /******/ 	
+  /************************************************************************/
+  /******/ 	/* webpack/runtime/compat */
+  /******/ 	
+  /******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
+  /******/ 	
+  /************************************************************************/
+  var __webpack_exports__ = {};
+  // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+  !function() {
+  var exports = __webpack_exports__;
+  /*
+    MIT License http://www.opensource.org/licenses/mit-license.php
+    Author Tobias Koppers @sokra
+  */
+  var fs = __nccwpck_require__(147);
+  var readFile = fs.readFile.bind(fs);
+  var loadLoader = __nccwpck_require__(713);
+
+  function utf8BufferToString(buf) {
+    var str = buf.toString("utf-8");
+    if(str.charCodeAt(0) === 0xFEFF) {
+      return str.substr(1);
+    } else {
+      return str;
+    }
+  }
+
+  const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+
+  /**
+   * @param {string} str the path with query and fragment
+   * @returns {{ path: string, query: string, fragment: string }} parsed parts
+   */
+  function parsePathQueryFragment(str) {
+    var match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+    return {
+      path: match[1].replace(/\0(.)/g, "$1"),
+      query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
+      fragment: match[3] || ""
+    };
+  }
+
+  function dirname(path) {
+    if(path === "/") return "/";
+    var i = path.lastIndexOf("/");
+    var j = path.lastIndexOf("\\");
+    var i2 = path.indexOf("/");
+    var j2 = path.indexOf("\\");
+    var idx = i > j ? i : j;
+    var idx2 = i > j ? i2 : j2;
+    if(idx < 0) return path;
+    if(idx === idx2) return path.substr(0, idx + 1);
+    return path.substr(0, idx);
+  }
+
+  function createLoaderObject(loader) {
+    var obj = {
+      path: null,
+      query: null,
+      fragment: null,
+      options: null,
+      ident: null,
+      normal: null,
+      pitch: null,
+      raw: null,
+      data: null,
+      pitchExecuted: false,
+      normalExecuted: false
+    };
+    Object.defineProperty(obj, "request", {
+      enumerable: true,
+      get: function() {
+        return obj.path.replace(/#/g, "\0#") + obj.query.replace(/#/g, "\0#") + obj.fragment;
+      },
+      set: function(value) {
+        if(typeof value === "string") {
+          var splittedRequest = parsePathQueryFragment(value);
+          obj.path = splittedRequest.path;
+          obj.query = splittedRequest.query;
+          obj.fragment = splittedRequest.fragment;
+          obj.options = undefined;
+          obj.ident = undefined;
+        } else {
+          if(!value.loader)
+            throw new Error("request should be a string or object with loader and options (" + JSON.stringify(value) + ")");
+          obj.path = value.loader;
+          obj.fragment = value.fragment || "";
+          obj.type = value.type;
+          obj.options = value.options;
+          obj.ident = value.ident;
+          if(obj.options === null)
+            obj.query = "";
+          else if(obj.options === undefined)
+            obj.query = "";
+          else if(typeof obj.options === "string")
+            obj.query = "?" + obj.options;
+          else if(obj.ident)
+            obj.query = "??" + obj.ident;
+          else if(typeof obj.options === "object" && obj.options.ident)
+            obj.query = "??" + obj.options.ident;
+          else
+            obj.query = "?" + JSON.stringify(obj.options);
+        }
+      }
+    });
+    obj.request = loader;
+    if(Object.preventExtensions) {
+      Object.preventExtensions(obj);
+    }
+    return obj;
+  }
+
+  function runSyncOrAsync(fn, context, args, callback) {
+    var isSync = true;
+    var isDone = false;
+    var isError = false; // internal error
+    var reportedError = false;
+    context.async = function async() {
+      if(isDone) {
+        if(reportedError) return; // ignore
+        throw new Error("async(): The callback was already called.");
+      }
+      isSync = false;
+      return innerCallback;
+    };
+    var innerCallback = context.callback = function() {
+      if(isDone) {
+        if(reportedError) return; // ignore
+        throw new Error("callback(): The callback was already called.");
+      }
+      isDone = true;
+      isSync = false;
+      try {
+        callback.apply(null, arguments);
+      } catch(e) {
+        isError = true;
+        throw e;
+      }
+    };
+    try {
+      var result = (function LOADER_EXECUTION() {
+        return fn.apply(context, args);
+      }());
+      if(isSync) {
+        isDone = true;
+        if(result === undefined)
+          return callback();
+        if(result && typeof result === "object" && typeof result.then === "function") {
+          return result.then(function(r) {
+            callback(null, r);
+          }, callback);
+        }
+        return callback(null, result);
+      }
+    } catch(e) {
+      if(isError) throw e;
+      if(isDone) {
+        // loader is already "done", so we cannot use the callback function
+        // for better debugging we print the error on the console
+        if(typeof e === "object" && e.stack) console.error(e.stack);
+        else console.error(e);
+        return;
+      }
+      isDone = true;
+      reportedError = true;
+      callback(e);
+    }
+
+  }
+
+  function convertArgs(args, raw) {
+    if(!raw && Buffer.isBuffer(args[0]))
+      args[0] = utf8BufferToString(args[0]);
+    else if(raw && typeof args[0] === "string")
+      args[0] = Buffer.from(args[0], "utf-8");
+  }
+
+  function iteratePitchingLoaders(options, loaderContext, callback) {
+    // abort after last loader
+    if(loaderContext.loaderIndex >= loaderContext.loaders.length)
+      return processResource(options, loaderContext, callback);
+
+    var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+
+    // iterate
+    if(currentLoaderObject.pitchExecuted) {
+      loaderContext.loaderIndex++;
+      return iteratePitchingLoaders(options, loaderContext, callback);
+    }
+
+    // load loader module
+    loadLoader(currentLoaderObject, function(err) {
+      if(err) {
+        loaderContext.cacheable(false);
+        return callback(err);
+      }
+      var fn = currentLoaderObject.pitch;
+      currentLoaderObject.pitchExecuted = true;
+      if(!fn) return iteratePitchingLoaders(options, loaderContext, callback);
+
+      runSyncOrAsync(
+        fn,
+        loaderContext, [loaderContext.remainingRequest, loaderContext.previousRequest, currentLoaderObject.data = {}],
+        function(err) {
+          if(err) return callback(err);
+          var args = Array.prototype.slice.call(arguments, 1);
+          // Determine whether to continue the pitching process based on
+          // argument values (as opposed to argument presence) in order
+          // to support synchronous and asynchronous usages.
+          var hasArg = args.some(function(value) {
+            return value !== undefined;
+          });
+          if(hasArg) {
+            loaderContext.loaderIndex--;
+            iterateNormalLoaders(options, loaderContext, args, callback);
+          } else {
+            iteratePitchingLoaders(options, loaderContext, callback);
+          }
+        }
+      );
+    });
+  }
+
+  function processResource(options, loaderContext, callback) {
+    // set loader index to last loader
+    loaderContext.loaderIndex = loaderContext.loaders.length - 1;
+
+    var resourcePath = loaderContext.resourcePath;
+    if(resourcePath) {
+      options.processResource(loaderContext, resourcePath, function(err) {
+        if(err) return callback(err);
+        var args = Array.prototype.slice.call(arguments, 1);
+        options.resourceBuffer = args[0];
+        iterateNormalLoaders(options, loaderContext, args, callback);
+      });
+    } else {
+      iterateNormalLoaders(options, loaderContext, [null], callback);
+    }
+  }
+
+  function iterateNormalLoaders(options, loaderContext, args, callback) {
+    if(loaderContext.loaderIndex < 0)
+      return callback(null, args);
+
+    var currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+
+    // iterate
+    if(currentLoaderObject.normalExecuted) {
+      loaderContext.loaderIndex--;
+      return iterateNormalLoaders(options, loaderContext, args, callback);
+    }
+
+    var fn = currentLoaderObject.normal;
+    currentLoaderObject.normalExecuted = true;
+    if(!fn) {
+      return iterateNormalLoaders(options, loaderContext, args, callback);
+    }
+
+    convertArgs(args, currentLoaderObject.raw);
+
+    runSyncOrAsync(fn, loaderContext, args, function(err) {
+      if(err) return callback(err);
+
+      var args = Array.prototype.slice.call(arguments, 1);
+      iterateNormalLoaders(options, loaderContext, args, callback);
+    });
+  }
+
+  exports.getContext = function getContext(resource) {
+    var path = parsePathQueryFragment(resource).path;
+    return dirname(path);
+  };
+
+  exports.runLoaders = function runLoaders(options, callback) {
+    // read options
+    var resource = options.resource || "";
+    var loaders = options.loaders || [];
+    var loaderContext = options.context || {};
+    var processResource = options.processResource || ((readResource, context, resource, callback) => {
+      context.addDependency(resource);
+      readResource(resource, callback);
+    }).bind(null, options.readResource || readFile);
+
+    //
+    var splittedResource = resource && parsePathQueryFragment(resource);
+    var resourcePath = splittedResource ? splittedResource.path : undefined;
+    var resourceQuery = splittedResource ? splittedResource.query : undefined;
+    var resourceFragment = splittedResource ? splittedResource.fragment : undefined;
+    var contextDirectory = resourcePath ? dirname(resourcePath) : null;
+
+    // execution state
+    var requestCacheable = true;
+    var fileDependencies = [];
+    var contextDependencies = [];
+    var missingDependencies = [];
+
+    // prepare loader objects
+    loaders = loaders.map(createLoaderObject);
+
+    loaderContext.context = contextDirectory;
+    loaderContext.loaderIndex = 0;
+    loaderContext.loaders = loaders;
+    loaderContext.resourcePath = resourcePath;
+    loaderContext.resourceQuery = resourceQuery;
+    loaderContext.resourceFragment = resourceFragment;
+    loaderContext.async = null;
+    loaderContext.callback = null;
+    loaderContext.getOptions = function getOptions() {
+      var entry = loaderContext.loaders[loaderContext.loaderIndex];
+      return entry.options && typeof entry.options === "object" ? entry.options : {};
+    };
+
+    loaderContext.cacheable = function cacheable(flag) {
+      if(flag === false) {
+        requestCacheable = false;
+      }
+    };
+    loaderContext.dependency = loaderContext.addDependency = function addDependency(file) {
+      fileDependencies.push(file);
+    };
+    loaderContext.addContextDependency = function addContextDependency(context) {
+      contextDependencies.push(context);
+    };
+    loaderContext.addMissingDependency = function addMissingDependency(context) {
+      missingDependencies.push(context);
+    };
+    loaderContext.getDependencies = function getDependencies() {
+      return fileDependencies.slice();
+    };
+    loaderContext.getContextDependencies = function getContextDependencies() {
+      return contextDependencies.slice();
+    };
+    loaderContext.getMissingDependencies = function getMissingDependencies() {
+      return missingDependencies.slice();
+    };
+    loaderContext.clearDependencies = function clearDependencies() {
+      fileDependencies.length = 0;
+      contextDependencies.length = 0;
+      missingDependencies.length = 0;
+      requestCacheable = true;
+    };
+    Object.defineProperty(loaderContext, "resource", {
+      enumerable: true,
+      get: function() {
+        if(loaderContext.resourcePath === undefined)
+          return undefined;
+        return loaderContext.resourcePath.replace(/#/g, "\0#") + loaderContext.resourceQuery.replace(/#/g, "\0#") + loaderContext.resourceFragment;
+      },
+      set: function(value) {
+        var splittedResource = value && parsePathQueryFragment(value);
+        loaderContext.resourcePath = splittedResource ? splittedResource.path : undefined;
+        loaderContext.resourceQuery = splittedResource ? splittedResource.query : undefined;
+        loaderContext.resourceFragment = splittedResource ? splittedResource.fragment : undefined;
+      }
+    });
+    Object.defineProperty(loaderContext, "request", {
+      enumerable: true,
+      get: function() {
+        return loaderContext.loaders.map(function(o) {
+          return o.request;
+        }).concat(loaderContext.resource || "").join("!");
+      }
+    });
+    Object.defineProperty(loaderContext, "remainingRequest", {
+      enumerable: true,
+      get: function() {
+        if(loaderContext.loaderIndex >= loaderContext.loaders.length - 1 && !loaderContext.resource)
+          return "";
+        return loaderContext.loaders.slice(loaderContext.loaderIndex + 1).map(function(o) {
+          return o.request;
+        }).concat(loaderContext.resource || "").join("!");
+      }
+    });
+    Object.defineProperty(loaderContext, "currentRequest", {
+      enumerable: true,
+      get: function() {
+        return loaderContext.loaders.slice(loaderContext.loaderIndex).map(function(o) {
+          return o.request;
+        }).concat(loaderContext.resource || "").join("!");
+      }
+    });
+    Object.defineProperty(loaderContext, "previousRequest", {
+      enumerable: true,
+      get: function() {
+        return loaderContext.loaders.slice(0, loaderContext.loaderIndex).map(function(o) {
+          return o.request;
+        }).join("!");
+      }
+    });
+    Object.defineProperty(loaderContext, "query", {
+      enumerable: true,
+      get: function() {
+        var entry = loaderContext.loaders[loaderContext.loaderIndex];
+        return entry.options && typeof entry.options === "object" ? entry.options : entry.query;
+      }
+    });
+    Object.defineProperty(loaderContext, "data", {
+      enumerable: true,
+      get: function() {
+        return loaderContext.loaders[loaderContext.loaderIndex].data;
+      }
+    });
+
+    // finish loader context
+    if(Object.preventExtensions) {
+      Object.preventExtensions(loaderContext);
+    }
+
+    var processOptions = {
+      resourceBuffer: null,
+      processResource: processResource
+    };
+    iteratePitchingLoaders(processOptions, loaderContext, function(err, result) {
+      if(err) {
+        return callback(err, {
+          cacheable: requestCacheable,
+          fileDependencies: fileDependencies,
+          contextDependencies: contextDependencies,
+          missingDependencies: missingDependencies
+        });
+      }
+      callback(null, {
+        result: result,
+        resourceBuffer: processOptions.resourceBuffer,
+        cacheable: requestCacheable,
+        fileDependencies: fileDependencies,
+        contextDependencies: contextDependencies,
+        missingDependencies: missingDependencies
+      });
+    });
+  };
+
+  }();
+  module.exports = __webpack_exports__;
+  /******/ })()
+  ;

package/dist/client/theme-api/useSiteSearch/index.js

@@ -7,7 +7,7 @@ function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 import { useNavData } from 'dumi';
 import { useCallback, useEffect, useRef, useState } from 'react';
 // @ts-ignore
-import workerCode from '-!../../../../compiled/_internal/searchWorker.min?dumi-raw';
+import workerCode from "../../../../compiled/_internal/searchWorker.min?dumi-raw";
 import useSearchData from "./useSearchData";
 var worker;
 

package/dist/features/compile/index.d.ts

@@ -1,3 +1,4 @@
-import type { IApi } from "../../types";
+import type { IApi, IDumiTechStack } from "../../types";
+export declare const techStacks: IDumiTechStack[];
 declare const _default: (api: IApi) => void;
 export default _default;