@plugjs/tsrun 0.4.0

package/dist/loader.mjs

@@ -0,0 +1,266 @@
+// src/loader.mts
+import _fs from "node:fs";
+import _module from "node:module";
+import _path from "node:path";
+import _url from "node:url";
+import _util from "node:util";
+import _esbuild from "esbuild";
+var CJS = "commonjs";
+var ESM = "module";
+var _debugLog = _util.debuglog("plug:ts-loader");
+var _debug = _debugLog.enabled;
+function _log(type, arg, ...args) {
+  if (!_debug)
+    return;
+  const t = type === ESM ? "esm" : type === CJS ? "cjs" : "---";
+  _debugLog(`[${t}] ${arg}`, ...args);
+}
+function _throw(type, message, options = {}) {
+  const t = type === ESM ? "esm" : type === CJS ? "cjs" : "---";
+  const prefix = `[ts-loader|${t}|pid=${process.pid}]`;
+  const { start = _throw, ...extra } = options;
+  const error = new Error(`${prefix} ${message}`);
+  Error.captureStackTrace(error, start);
+  Object.assign(error, extra);
+  throw error;
+}
+function _checkType(type) {
+  if (type === CJS)
+    return CJS;
+  if (type === ESM)
+    return ESM;
+  _throw(null, `Invalid type "${process.env.__TS_LOADER_FORCE_TYPE}"`);
+}
+var _type = (() => {
+  if (process.env.__TS_LOADER_FORCE_TYPE) {
+    const type = process.env.__TS_LOADER_FORCE_TYPE;
+    _log(null, `Forcing type to "${type}" from environment`);
+    return _checkType(type);
+  }
+  const findType = (directory) => {
+    const packageFile = _path.join(directory, "package.json");
+    try {
+      const packageData = _fs.readFileSync(packageFile, "utf-8");
+      const packageJson = JSON.parse(packageData);
+      const packageType = packageJson.type;
+      switch (packageType) {
+        case void 0:
+          _log(null, `File "${packageFile}" does not declare a default type`);
+          return CJS;
+        case CJS:
+        case ESM:
+          _log(null, `File "${packageFile}" declares type as "${CJS}"`);
+          return packageType;
+        default:
+          _log(null, `File "${packageFile}" specifies unknown type "${packageType}"`);
+          return CJS;
+      }
+    } catch (cause) {
+      if (cause.code !== "ENOENT" && cause.code !== "EISDIR") {
+        _throw(null, `Unable to read or parse "${packageFile}"`, { cause, start: findType });
+      }
+    }
+    const parent = _path.dirname(directory);
+    if (directory !== parent)
+      return findType(directory);
+    _log(null, `Type defaulted to "${CJS}"`);
+    return CJS;
+  };
+  return findType(process.cwd());
+})();
+var tsLoaderMarker = Symbol.for("plugjs:tsLoader");
+Object.defineProperty(globalThis, tsLoaderMarker, {
+  set(type) {
+    _log(null, `Setting type to "${type}"`);
+    process.env.__TS_LOADER_FORCE_TYPE = _type = _checkType(type);
+  },
+  get() {
+    return _type;
+  }
+});
+function _esbReport(kind, messages = []) {
+  const output = process.stderr;
+  const options = { color: !!output.isTTY, terminalWidth: output.columns || 80 };
+  const array = _esbuild.formatMessagesSync(messages, { kind, ...options });
+  array.forEach((message) => output.write(`${message}
+`));
+}
+function _esbTranpile(filename, type) {
+  _log(type, `Transpiling "${filename}`);
+  const [format, __fileurl] = type === ESM ? ["esm", "import.meta.url"] : ["cjs", "__filename"];
+  const options = {
+    sourcefile: filename,
+    // the original filename we're parsing
+    format,
+    // what are we actually transpiling to???
+    loader: "ts",
+    // the format is always "typescript"
+    sourcemap: "inline",
+    // always inline source maps
+    sourcesContent: false,
+    // do not include sources content in sourcemap
+    platform: "node",
+    // d'oh! :-)
+    minifyWhitespace: true,
+    // https://github.com/evanw/esbuild/releases/tag/v0.16.14
+    logLevel: "silent",
+    // catching those in our _esbReport below
+    target: `node${process.versions["node"]}`,
+    // target _this_ version
+    define: { __fileurl }
+    // from "globals.d.ts"
+  };
+  if (_debug) {
+    if (format === "esm") {
+      options.banner = `;(await import('node:util')).debuglog('plug:ts-loader')('[esm] Loaded "%s"', ${__fileurl});`;
+    } else if (format === "cjs") {
+      options.banner = `;require('node:util').debuglog('plug:ts-loader')('[cjs] Loaded "%s"', ${__fileurl});`;
+    }
+  }
+  let result;
+  try {
+    const source = _fs.readFileSync(filename, "utf-8");
+    result = _esbuild.transformSync(source, options);
+  } catch (cause) {
+    _esbReport("error", cause.errors);
+    _esbReport("warning", cause.warnings);
+    _throw(type, `ESBuild error transpiling "${filename}"`, { cause, start: _esbTranpile });
+  }
+  if (_debug)
+    _esbReport("warning", result.warnings);
+  return result.code;
+}
+function isFile(path) {
+  try {
+    return _fs.statSync(path).isFile();
+  } catch (error) {
+    return false;
+  }
+}
+function isDirectory(path) {
+  try {
+    return _fs.statSync(path).isDirectory();
+  } catch (error) {
+    return false;
+  }
+}
+var resolve = (specifier, context, nextResolve) => {
+  _log(ESM, `Resolving "${specifier}" from "${context.parentURL}"`);
+  if (!specifier.match(/^\.\.?\//))
+    return nextResolve(specifier, context);
+  const parentURL = context.parentURL;
+  if (!parentURL)
+    return nextResolve(specifier, context);
+  if (!parentURL.startsWith("file:"))
+    return nextResolve(specifier, context);
+  if (!parentURL.match(/\.m?ts$/))
+    return nextResolve(specifier, context);
+  const url = new URL(specifier, parentURL).href;
+  const path = _url.fileURLToPath(url);
+  if (isFile(path)) {
+    _log(ESM, `Positive match for "${specifier}" as "${path}" (1)`);
+    return nextResolve(specifier, context);
+  }
+  const match = specifier.match(/(.*)(\.[mc]?js$)/);
+  if (match) {
+    const [, base, ext] = match;
+    const tsspecifier = base + ext.replace("js", "ts");
+    const tsurl = new URL(tsspecifier, parentURL).href;
+    const tspath = _url.fileURLToPath(tsurl);
+    if (isFile(tspath)) {
+      _log(ESM, `Positive match for "${specifier}" as "${tspath}" (2)`);
+      return nextResolve(tsspecifier, context);
+    }
+  }
+  if (isFile(`${path}.ts`)) {
+    _log(ESM, `Positive match for "${specifier}.ts" as "${path}.ts" (3)`);
+    return nextResolve(`${specifier}.ts`, context);
+  }
+  if (isDirectory(path)) {
+    const file = _path.resolve(path, "index.ts");
+    if (isFile(file)) {
+      _log(ESM, `Positive match for "${specifier}" as "${file}"  (4)`);
+      const spec = _url.pathToFileURL(file).pathname;
+      return nextResolve(spec, context);
+    }
+  }
+  return nextResolve(specifier, context);
+};
+var load = (url, context, nextLoad) => {
+  _log(ESM, `Attempting to load "${url}"`);
+  if (!url.startsWith("file:"))
+    return nextLoad(url, context);
+  const ext = url.match(/\.[cm]?ts$/)?.[0];
+  if (!ext)
+    return nextLoad(url, context);
+  if (ext === ".cts") {
+    if (_debug) {
+      _log(null, `Switching type from "module" to "commonjs" for "${url}"`);
+      _log(null, "Please note that named import WILL NOT WORK in this case, as Node.js performs a");
+      _log(null, "static analisys on the CommonJS source code, and this file is transpiled from.");
+      _log(null, "TypeScript to CommonJS dynamically.");
+    }
+    return { format: CJS, shortCircuit: true };
+  }
+  const filename = _url.fileURLToPath(url);
+  if (ext === ".ts") {
+    if (_type === CJS) {
+      if (_debug) {
+        _log(null, `Switching type from "module" to "commonjs" for "${url}"`);
+        _log(null, "Please note that named import WILL NOT WORK in this case, as Node.js performs a");
+        _log(null, "static analisys on the CommonJS source code, and this file is transpiled from.");
+        _log(null, "TypeScript to CommonJS dynamically.");
+      }
+      return { format: CJS, shortCircuit: true };
+    }
+  }
+  const source = _esbTranpile(filename, ESM);
+  return { source, format: ESM, shortCircuit: true };
+};
+var loader = (module, filename) => {
+  _log(CJS, `Attempting to load "${filename}"`);
+  const ext = _path.extname(filename);
+  if (ext === ".ts") {
+    if (_type === ESM) {
+      _throw(CJS, `Must use import to load ES Module: ${filename}`, { code: "ERR_REQUIRE_ESM" });
+    }
+  } else if (ext !== ".cts") {
+    _throw(CJS, `Unsupported filename "${filename}"`);
+  }
+  const source = _esbTranpile(filename, CJS);
+  try {
+    module._compile(source, filename);
+  } catch (cause) {
+    console.error(`Error compiling module "${filename}"`, cause);
+  }
+};
+_module._extensions[".ts"] = _module._extensions[".cts"] = loader;
+var _oldResolveFilename = _module._resolveFilename;
+_module._resolveFilename = function(request, parent, ...args) {
+  try {
+    return _oldResolveFilename.call(this, request, parent, ...args);
+  } catch (error) {
+    if (error.code !== "MODULE_NOT_FOUND")
+      throw error;
+    const match = request.match(/(.*)(\.[mc]?js$)/);
+    if (parent && match) {
+      const [, name, ext] = match;
+      const tsrequest = name + ext.replace("js", "ts");
+      try {
+        const result = _oldResolveFilename.call(this, tsrequest, parent, ...args);
+        _log(CJS, `Resolution for "${request}" intercepted as "${tsrequest}`);
+        return result;
+      } catch (discard) {
+        throw error;
+      }
+    }
+    throw error;
+  }
+};
+export {
+  isDirectory,
+  isFile,
+  load,
+  resolve
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/parser.d.mts

@@ -0,0 +1,118 @@
+// Type definitions for yargs-parser 21.0
+// Project: https://github.com/yargs/yargs-parser#readme
+// Definitions by: Miles Johnson <https://github.com/milesj>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
+
+declare namespace yargsParser {
+    interface Arguments {
+        /** Non-option arguments */
+        _: Array<string | number>;
+        /** Arguments after the end-of-options flag `--` */
+        '--'?: Array<string | number>;
+        /** All remaining options */
+        [argName: string]: any;
+    }
+
+    interface DetailedArguments {
+        /** An object representing the parsed value of `args` */
+        argv: Arguments;
+        /** Populated with an error object if an exception occurred during parsing. */
+        error: Error | null;
+        /** The inferred list of aliases built by combining lists in opts.alias. */
+        aliases: { [alias: string]: string[] };
+        /** Any new aliases added via camel-case expansion. */
+        newAliases: { [alias: string]: boolean };
+        /** The configuration loaded from the yargs stanza in package.json. */
+        configuration: Configuration;
+    }
+
+    interface Configuration {
+        /** Should variables prefixed with --no be treated as negations? Default is `true` */
+        'boolean-negation': boolean;
+        /** Should hyphenated arguments be expanded into camel-case aliases? Default is `true` */
+        'camel-case-expansion': boolean;
+        /** Should arrays be combined when provided by both command line arguments and a configuration file. Default is `false`  */
+        'combine-arrays': boolean;
+        /** Should keys that contain . be treated as objects? Default is `true` */
+        'dot-notation': boolean;
+        /** Should arguments be coerced into an array when duplicated. Default is `true` */
+        'duplicate-arguments-array': boolean;
+        /** Should array arguments be coerced into a single array when duplicated. Default is `true` */
+        'flatten-duplicate-arrays': boolean;
+        /** Should arrays consume more than one positional argument following their flag. Default is `true` */
+        'greedy-arrays': boolean;
+        /** Should nargs consume dash options as well as positional arguments. Default is `false` */
+        'nargs-eats-options': boolean;
+        /** Should parsing stop at the first text argument? This is similar to how e.g. ssh parses its command line. Default is `false` */
+        'halt-at-non-option': boolean;
+        /** The prefix to use for negated boolean variables. Default is `'no-'` */
+        'negation-prefix': string;
+        /** Should keys that look like numbers be treated as such? Default is `true` */
+        'parse-numbers': boolean;
+        /** Should positional keys that look like numbers be treated as such? Default is `true` */
+        'parse-positional-numbers': boolean;
+        /** Should unparsed flags be stored in -- or _. Default is `false` */
+        'populate--': boolean;
+        /** Should a placeholder be added for keys not set via the corresponding CLI argument? Default is `false` */
+        'set-placeholder-key': boolean;
+        /** Should a group of short-options be treated as boolean flags? Default is `true` */
+        'short-option-groups': boolean;
+        /** Should aliases be removed before returning results? Default is `false` */
+        'strip-aliased': boolean;
+        /** Should dashed keys be removed before returning results? This option has no effect if camel-case-expansion is disabled. Default is `false` */
+        'strip-dashed': boolean;
+        /** Should unknown options be treated like regular arguments? An unknown option is one that is not configured in opts. Default is `false` */
+        'unknown-options-as-args': boolean;
+    }
+
+    interface Options {
+        /** An object representing the set of aliases for a key: `{ alias: { foo: ['f']} }`. */
+        alias?: { [key: string]: string | string[] } | undefined;
+        /**
+         * Indicate that keys should be parsed as an array: `{ array: ['foo', 'bar'] }`.
+         * Indicate that keys should be parsed as an array and coerced to booleans / numbers:
+         * { array: [ { key: 'foo', boolean: true }, {key: 'bar', number: true} ] }`.
+         */
+        array?:
+            | string[]
+            | Array<{ key: string; boolean?: boolean | undefined; number?: boolean | undefined }>
+            | undefined;
+        /** Arguments should be parsed as booleans: `{ boolean: ['x', 'y'] }`. */
+        boolean?: string[] | undefined;
+        /** Indicate a key that represents a path to a configuration file (this file will be loaded and parsed). */
+        config?: string | string[] | { [key: string]: boolean } | undefined;
+        /** Provide configuration options to the yargs-parser. */
+        configuration?: Partial<Configuration> | undefined;
+        /**
+         * Provide a custom synchronous function that returns a coerced value from the argument provided (or throws an error), e.g.
+         * `{ coerce: { foo: function (arg) { return modifiedArg } } }`.
+         */
+        coerce?: { [key: string]: (arg: any) => any } | undefined;
+        /** Indicate a key that should be used as a counter, e.g., `-vvv = {v: 3}`. */
+        count?: string[] | undefined;
+        /** Provide default values for keys: `{ default: { x: 33, y: 'hello world!' } }`. */
+        default?: { [key: string]: any } | undefined;
+        /** Environment variables (`process.env`) with the prefix provided should be parsed. */
+        envPrefix?: string | undefined;
+        /** Specify that a key requires n arguments: `{ narg: {x: 2} }`. */
+        narg?: { [key: string]: number } | undefined;
+        /** `path.normalize()` will be applied to values set to this key. */
+        normalize?: string[] | undefined;
+        /** Keys should be treated as strings (even if they resemble a number `-x 33`). */
+        string?: string[] | undefined;
+        /** Keys should be treated as numbers. */
+        number?: string[] | undefined;
+    }
+
+    interface Parser {
+        (argv: string | string[], opts?: Options): Arguments;
+        detailed(argv: string | string[], opts?: Options): DetailedArguments;
+        camelCase(str: string): string;
+        decamelize(str: string, joinString?: string): string;
+        looksLikeNumber(value: string | number | null | undefined): boolean;
+    }
+}
+
+declare var yargsParser: yargsParser.Parser;
+export = yargsParser;