@powerlines/deepkit 0.5.0 → 0.5.2

package/dist/vendor/chunk-IOMA7ABE.js

@@ -0,0 +1,359 @@
+import { dirname, join, isAbsolute } from 'path';
+import ts2 from 'typescript';
+import { readFileSync } from 'fs';
+import micromatch from 'micromatch';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=88e8267ac73f46799c551ae3696181dc1f272895f490f8c_ef8b874d406bec4900e1fddc1ea375be/node_modules/@deepkit/type-compiler/dist/esm/src/debug.js
+function isDebug(level = 1) {
+  const expected = "deepkit" + (level > 1 ? "+".repeat(level - 1) : "");
+  return "undefined" !== typeof process && "string" === typeof process.env.DEBUG && process.env.DEBUG.includes(expected);
+}
+__name(isDebug, "isDebug");
+function debug(...message) {
+  if (isDebug(1)) {
+    console.debug(...message);
+  }
+}
+__name(debug, "debug");
+function debug2(...message) {
+  if (isDebug(2)) {
+    console.debug(...message);
+  }
+}
+__name(debug2, "debug2");
+var { createSourceFile, resolveModuleName, isStringLiteral, JSDocParsingMode, ScriptTarget } = ts2;
+function patternMatch(path, patterns, base) {
+  const include = patterns.filter((pattern) => pattern[0] !== "!");
+  const exclude = patterns.filter((pattern) => pattern[0] === "!").map((pattern) => pattern.substring(1));
+  return micromatch.isMatch(path, include, {
+    ignore: exclude
+  });
+}
+__name(patternMatch, "patternMatch");
+var Resolver = class {
+  static {
+    __name(this, "Resolver");
+  }
+  constructor(compilerOptions, host, sourceFiles) {
+    this.compilerOptions = compilerOptions;
+    this.host = host;
+    this.sourceFiles = sourceFiles;
+  }
+  resolve(from, importOrExportNode) {
+    const moduleSpecifier = importOrExportNode.moduleSpecifier;
+    if (!moduleSpecifier) return;
+    if (!isStringLiteral(moduleSpecifier)) return;
+    return this.resolveSourceFile(from, moduleSpecifier);
+  }
+  resolveImpl(modulePath, sourceFile) {
+    if (this.host.resolveModuleNameLiterals !== void 0) {
+      const results = this.host.resolveModuleNameLiterals(
+        [
+          modulePath
+        ],
+        sourceFile.fileName,
+        /*reusedNames*/
+        void 0,
+        this.compilerOptions,
+        sourceFile,
+        void 0
+      );
+      if (results[0]) return results[0].resolvedModule;
+      return;
+    }
+    if (this.host.resolveModuleNames !== void 0) {
+      return this.host.resolveModuleNames(
+        [
+          modulePath.text
+        ],
+        sourceFile.fileName,
+        /*reusedNames*/
+        void 0,
+        /*redirectedReference*/
+        void 0,
+        this.compilerOptions
+      )[0];
+    }
+    const result = resolveModuleName(modulePath.text, sourceFile.fileName, this.compilerOptions, this.host);
+    return result.resolvedModule;
+  }
+  /**
+   * Tries to resolve the .ts/d.ts file path for a given module path.
+   * Scans relative paths. Looks into package.json "types" and "exports" (with new 4.7 support)
+   *
+   * @param sourceFile the SourceFile of the file that contains the import. modulePath is relative to that.
+   * @param modulePath the x in 'from x'.
+   */
+  resolveSourceFile(sourceFile, modulePath) {
+    const result = this.resolveImpl(modulePath, sourceFile);
+    if (!result) return;
+    if (!result.resolvedFileName.endsWith(".ts") && !result.resolvedFileName.endsWith(".tsx") && !result.resolvedFileName.endsWith(".d.ts")) {
+      return;
+    }
+    const fileName = result.resolvedFileName;
+    if (this.sourceFiles[fileName]) return this.sourceFiles[fileName];
+    const source = this.host.readFile(result.resolvedFileName);
+    if (!source) return;
+    const moduleSourceFile = this.sourceFiles[fileName] = createSourceFile(fileName, source, {
+      languageVersion: this.compilerOptions.target || ScriptTarget.ES2018,
+      // JSDocParsingMode is not available in TS < 5.3
+      jsDocParsingMode: JSDocParsingMode ? JSDocParsingMode.ParseNone : void 0
+    }, true);
+    this.sourceFiles[fileName] = moduleSourceFile;
+    ts2.bindSourceFile(moduleSourceFile, this.compilerOptions);
+    return moduleSourceFile;
+  }
+};
+
+// ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=88e8267ac73f46799c551ae3696181dc1f272895f490f8c_ef8b874d406bec4900e1fddc1ea375be/node_modules/@deepkit/type-compiler/dist/esm/src/config.js
+var reflectionModes = [
+  "default",
+  "explicit",
+  "never"
+];
+function isObject(obj) {
+  if (!obj) {
+    return false;
+  }
+  return typeof obj === "object" && !Array.isArray(obj);
+}
+__name(isObject, "isObject");
+var defaultMergeStrategy = "merge";
+var reflectionLevel = [
+  "minimal",
+  "normal",
+  "verbose"
+];
+function readTsConfig(parseConfigHost, path) {
+  const configFile = ts2.readConfigFile(path, (path2) => parseConfigHost.readFile(path2));
+  if (configFile.error) {
+    debug(`Failed to read tsconfig ${path}: ${configFile.error.messageText}`);
+    return;
+  }
+  const parsed = ts2.parseJsonConfigFileContent(configFile.config, parseConfigHost, dirname(path));
+  const ignoredErrors = [
+    18003
+    // No inputs were found in config file.
+  ];
+  const softErrors = [
+    18e3
+    // Circularity detected while resolving configuration
+  ];
+  const errors = parsed.errors.filter((v) => !ignoredErrors.includes(v.code));
+  if (errors.length) {
+    debug(`Failed to parse tsconfig ${path}: ${parsed.errors.map((v) => v.messageText).join(", ")}`);
+  }
+  const hardErrors = errors.filter((v) => !softErrors.includes(v.code));
+  if (hardErrors.length) {
+    return;
+  }
+  const json = readFileSync(path, "utf8");
+  const tsconfig = JSON.parse(json);
+  return Object.assign(configFile.config, {
+    compilerOptions: parsed.options,
+    reflectionLevel: tsconfig.reflectionLevel ? String(tsconfig.reflectionLevel) : void 0
+  });
+}
+__name(readTsConfig, "readTsConfig");
+function reflectionModeMatcher(config, filePath) {
+  if (Array.isArray(config.exclude)) {
+    if (patternMatch(filePath, config.exclude)) return "never";
+  }
+  if (Array.isArray(config.reflection)) {
+    return patternMatch(filePath, config.reflection) ? "default" : "never";
+  }
+  if (config.reflection === "default" || config.reflection === "explicit") return config.reflection;
+  return "never";
+}
+__name(reflectionModeMatcher, "reflectionModeMatcher");
+function ensureStringArray(value) {
+  if (Array.isArray(value)) return value.map((v) => "" + v);
+  if ("string" === typeof value) return [
+    value
+  ];
+  return [];
+}
+__name(ensureStringArray, "ensureStringArray");
+function parseRawMode(mode) {
+  if ("boolean" === typeof mode) return mode ? "default" : "never";
+  if (mode === "default" || mode === "explicit") return mode;
+  return ensureStringArray(mode);
+}
+__name(parseRawMode, "parseRawMode");
+function resolvePaths(baseDir, paths) {
+  if (!paths || !Array.isArray(paths)) return;
+  for (let i = 0; i < paths.length; i++) {
+    if ("string" !== typeof paths[i]) continue;
+    if (isAbsolute(paths[i])) continue;
+    let path = paths[i];
+    let exclude = false;
+    if (path.startsWith("!")) {
+      exclude = true;
+      path = path.substring(1);
+    }
+    if (path.startsWith("./") || path.includes("/")) {
+      path = join(baseDir, path);
+    }
+    path = path.replace(/\\/g, "/");
+    if (exclude) path = "!" + path;
+    paths[i] = path;
+  }
+}
+__name(resolvePaths, "resolvePaths");
+function appendPaths(strategy = defaultMergeStrategy, parent, existing) {
+  if (strategy === "replace") {
+    return [
+      ...existing || parent
+    ];
+  }
+  if (!existing) return [
+    ...parent
+  ];
+  return [
+    ...parent,
+    ...existing
+  ];
+}
+__name(appendPaths, "appendPaths");
+function applyConfigValues(existing, parent, baseDir) {
+  const parentReflection = isObject(parent.deepkitCompilerOptions) ? parent.deepkitCompilerOptions?.reflection : parent.reflection;
+  const parentReflectionLevel = parent.deepkitCompilerOptions?.reflectionLevel || parent.reflectionLevel || parent.compilerOptions?.reflectionLevel;
+  if (isObject(parent.deepkitCompilerOptions) && "undefined" === typeof existing.mergeStrategy) {
+    existing.mergeStrategy = parent.deepkitCompilerOptions.mergeStrategy;
+  }
+  if ("undefined" !== typeof parentReflection) {
+    const next = parseRawMode(parentReflection);
+    if ("undefined" === typeof existing.reflection) {
+      existing.reflection = next;
+    } else if ("string" === typeof existing.reflection) ; else if (Array.isArray(next) && Array.isArray(existing.reflection)) {
+      existing.reflection = appendPaths(existing.mergeStrategy, next, existing.reflection);
+    } else if ("string" === typeof next && Array.isArray(existing.reflection)) ;
+  }
+  if ("undefined" !== typeof parentReflectionLevel) {
+    if ("undefined" === typeof existing.reflectionLevel) {
+      existing.reflectionLevel = parentReflectionLevel;
+    }
+  }
+  if (isObject(parent.deepkitCompilerOptions)) {
+    if (`undefined` !== typeof parent.deepkitCompilerOptions.exclude) {
+      const next = ensureStringArray(parent.deepkitCompilerOptions.exclude);
+      existing.exclude = appendPaths(existing.mergeStrategy, next, existing.exclude);
+    }
+  }
+  resolvePaths(baseDir, existing.reflection);
+  resolvePaths(baseDir, existing.exclude);
+  if (parent.compilerOptions) {
+    if (Object.keys(existing.compilerOptions).length === 0) {
+      Object.assign(existing.compilerOptions, parent.compilerOptions);
+    }
+  }
+  existing.extends = parent.extends;
+}
+__name(applyConfigValues, "applyConfigValues");
+var defaultExcluded = [
+  "lib.dom*.d.ts",
+  "*typedarrays.d.ts",
+  "lib.webworker*.d.ts",
+  "lib.decorator*.d.ts",
+  "lib.es2015.proxy.d.ts",
+  "lib.es2020.sharedmemory.d.ts",
+  "lib.es2015.core.d.ts"
+];
+function getConfigResolver(cache, host, compilerOptions, sourceFile, tsConfigPath = "") {
+  let config = {
+    // We use the parameter `compilerOptions` only for compilerOptions.configFilePath.
+    // We load the compilerOptions manually since transformers don't get the full picture
+    // (path aliases are missing for example).
+    // It's important to load compilerOptions manually if there is compilerOptions.configFilePath
+    // since not all build tools provide the full compilerOptions.
+    compilerOptions: {}
+  };
+  tsConfigPath = tsConfigPath || ("string" === typeof compilerOptions.configFilePath ? compilerOptions.configFilePath : "");
+  if (tsConfigPath) {
+    if (cache[tsConfigPath]) {
+      return cache[tsConfigPath];
+    }
+    const configFile = readTsConfig(host, tsConfigPath);
+    if (configFile) applyConfigValues(config, configFile, dirname(tsConfigPath));
+  } else {
+    if (!tsConfigPath && sourceFile) {
+      const baseDir = dirname(sourceFile.fileName);
+      const configPath = ts2.findConfigFile(baseDir, (path) => {
+        path = isAbsolute(path) ? path : join(baseDir, path);
+        return host.fileExists(path);
+      });
+      debug2(`No tsConfigPath|compilerOptions.configFilePath provided. Manually searching for tsconfig.json in ${baseDir} returned ${configPath}`);
+      if (configPath) {
+        tsConfigPath = isAbsolute(configPath) ? configPath : join(baseDir, configPath);
+      }
+    }
+    if (tsConfigPath) {
+      if (cache[tsConfigPath]) return cache[tsConfigPath];
+      const configFile = readTsConfig(host, tsConfigPath);
+      if (configFile) applyConfigValues(config, configFile, dirname(tsConfigPath));
+    }
+  }
+  if (tsConfigPath) {
+    let basePath = dirname(tsConfigPath);
+    let currentConfig = config;
+    const seen = /* @__PURE__ */ new Set();
+    seen.add(tsConfigPath);
+    while (currentConfig.extends) {
+      const path = join(basePath, currentConfig.extends);
+      if (seen.has(path)) break;
+      seen.add(path);
+      const nextConfig = ts2.readConfigFile(path, (path2) => host.readFile(path2));
+      if (!nextConfig) break;
+      basePath = dirname(path);
+      applyConfigValues(currentConfig, nextConfig.config, basePath);
+    }
+  } else {
+    throw new Error(`No tsconfig found for ${sourceFile?.fileName}, that is weird. Either provide a tsconfig or compilerOptions.configFilePath`);
+  }
+  config.exclude = config.exclude ? [
+    ...defaultExcluded,
+    ...config.exclude
+  ] : [
+    ...defaultExcluded
+  ];
+  config.compilerOptions.configFilePath = tsConfigPath;
+  const resolvedConfig = {
+    path: tsConfigPath,
+    // we want to maintain options passed from tsc API (transpile, Program)
+    compilerOptions: Object.assign(config.compilerOptions, compilerOptions),
+    exclude: config.exclude,
+    reflection: config.reflection,
+    reflectionLevel: config.reflectionLevel || (config.compilerOptions?.reflectionLevel ? String(config.compilerOptions?.reflectionLevel) : void 0) || "normal",
+    mergeStrategy: config.mergeStrategy || defaultMergeStrategy
+  };
+  if (isDebug()) {
+    debug(`Found config ${resolvedConfig.path}:
+reflection:`, resolvedConfig.reflection, `
+exclude:`, resolvedConfig.exclude, `
+paths:`, resolvedConfig.compilerOptions.paths);
+  }
+  const match = /* @__PURE__ */ __name((path) => {
+    const mode = reflectionModeMatcher(config, path);
+    return {
+      mode,
+      tsConfigPath,
+      level: resolvedConfig.reflectionLevel
+    };
+  }, "match");
+  return cache[tsConfigPath] = {
+    config: resolvedConfig,
+    match
+  };
+}
+__name(getConfigResolver, "getConfigResolver");
+
+export { Resolver, __name, __require, debug, debug2, defaultExcluded, getConfigResolver, isObject, parseRawMode, reflectionLevel, reflectionModeMatcher, reflectionModes };