@skmtc/core 0.28.4 → 0.28.6

package/README.md

@@ -16,7 +16,7 @@
 Skmtc is a Deno CLI. Install the latest version with:
 
 ```bash
-curl -fsSL https://skm.tc/install | sh
+curl -fsSL https://skmtc.dev/install | sh
 ```
 
 This bootstraps [Deno](https://deno.com) (the runtime) automatically if needed.

package/esm/_dnt.polyfills.d.ts

@@ -4,4 +4,102 @@ declare global {
     }
 }
 export {};
-//# sourceMappingURL=_dnt.polyfills.d.ts.map
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+import { createRequire } from "node:module";
+import { type URL } from "node:url";
+declare global {
+    interface ImportMeta {
+        /** A string representation of the fully qualified module URL. When the
+         * module is loaded locally, the value will be a file URL (e.g.
+         * `file:///path/module.ts`).
+         *
+         * You can also parse the string as a URL to determine more information about
+         * how the current module was loaded. For example to determine if a module was
+         * local or not:
+         *
+         * ```ts
+         * const url = new URL(import.meta.url);
+         * if (url.protocol === "file:") {
+         *   console.log("this module was loaded locally");
+         * }
+         * ```
+         */
+        url: string;
+        /**
+         * A function that returns resolved specifier as if it would be imported
+         * using `import(specifier)`.
+         *
+         * ```ts
+         * console.log(import.meta.resolve("./foo.js"));
+         * // file:///dev/foo.js
+         * ```
+         *
+         * @param specifier The module specifier to resolve relative to `parent`.
+         * @param parent The absolute parent module URL to resolve from.
+         * @returns The absolute (`file:`) URL string for the resolved module.
+         */
+        resolve(specifier: string, parent?: string | URL | undefined): string;
+        /** A flag that indicates if the current module is the main module that was
+         * called when starting the program under Deno.
+         *
+         * ```ts
+         * if (import.meta.main) {
+         *   // this was loaded as the main module, maybe do some bootstrapping
+         * }
+         * ```
+         */
+        main: boolean;
+        /** The absolute path of the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.filename); // /home/alice/my_module.ts
+         *
+         * // Windows
+         * console.log(import.meta.filename); // C:\alice\my_module.ts
+         * ```
+         */
+        filename: string;
+        /** The absolute path of the directory containing the current module.
+         *
+         * This property is only provided for local modules (ie. using `file://` URLs).
+         *
+         * * Example:
+         * ```
+         * // Unix
+         * console.log(import.meta.dirname); // /home/alice
+         *
+         * // Windows
+         * console.log(import.meta.dirname); // C:\alice
+         * ```
+         */
+        dirname: string;
+    }
+}
+type NodeRequest = ReturnType<typeof createRequire>;
+type NodeModule = NonNullable<NodeRequest["main"]>;
+interface ImportMetaPonyfillCommonjs {
+    (require: NodeRequest, module: NodeModule): ImportMeta;
+}
+interface ImportMetaPonyfillEsmodule {
+    (importMeta: ImportMeta): ImportMeta;
+}
+interface ImportMetaPonyfill extends ImportMetaPonyfillCommonjs, ImportMetaPonyfillEsmodule {
+}
+export declare let import_meta_ponyfill_commonjs: ImportMetaPonyfillCommonjs;
+export declare let import_meta_ponyfill_esmodule: ImportMetaPonyfillEsmodule;
+export declare let import_meta_ponyfill: ImportMetaPonyfill;

package/esm/_dnt.polyfills.js

@@ -1 +1,130 @@
-export {};
+/**
+ * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
+ * but instead of using npm to install additional dependencies,
+ * this approach manually consolidates cjs/mjs/d.ts into a single file.
+ *
+ * Note that this code might be imported multiple times
+ * (for example, both dnt.test.polyfills.ts and dnt.polyfills.ts contain this code;
+ *  or Node.js might dynamically clear the cache and then force a require).
+ * Therefore, it's important to avoid redundant writes to global objects.
+ * Additionally, consider that commonjs is used alongside esm,
+ * so the two ponyfill functions are stored independently in two separate global objects.
+ */
+//@ts-ignore
+import { createRequire } from "node:module";
+//@ts-ignore
+import { fileURLToPath, pathToFileURL } from "node:url";
+//@ts-ignore
+import { dirname } from "node:path";
+const defineGlobalPonyfill = (symbolFor, fn) => {
+    if (!Reflect.has(globalThis, Symbol.for(symbolFor))) {
+        Object.defineProperty(globalThis, Symbol.for(symbolFor), {
+            configurable: true,
+            get() {
+                return fn;
+            },
+        });
+    }
+};
+export let import_meta_ponyfill_commonjs = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-commonjs")) ??
+    (() => {
+        const moduleImportMetaWM = new WeakMap();
+        return (require, module) => {
+            let importMetaCache = moduleImportMetaWM.get(module);
+            if (importMetaCache == null) {
+                const importMeta = Object.assign(Object.create(null), {
+                    url: pathToFileURL(module.filename).href,
+                    main: require.main == module,
+                    resolve: (specifier, parentURL = importMeta.url) => {
+                        return pathToFileURL((importMeta.url === parentURL
+                            ? require
+                            : createRequire(parentURL))
+                            .resolve(specifier)).href;
+                    },
+                    filename: module.filename,
+                    dirname: module.path,
+                });
+                moduleImportMetaWM.set(module, importMeta);
+                importMetaCache = importMeta;
+            }
+            return importMetaCache;
+        };
+    })());
+defineGlobalPonyfill("import-meta-ponyfill-commonjs", import_meta_ponyfill_commonjs);
+export let import_meta_ponyfill_esmodule = (Reflect.get(globalThis, Symbol.for("import-meta-ponyfill-esmodule")) ??
+    ((importMeta) => {
+        const resolveFunStr = String(importMeta.resolve);
+        const shimWs = new WeakSet();
+        //@ts-ignore
+        const mainUrl = ("file:///" + process.argv[1].replace(/\\/g, "/"))
+            .replace(/\/{3,}/, "///");
+        const commonShim = (importMeta) => {
+            if (typeof importMeta.main !== "boolean") {
+                importMeta.main = importMeta.url === mainUrl;
+            }
+            if (typeof importMeta.filename !== "string") {
+                importMeta.filename = fileURLToPath(importMeta.url);
+                importMeta.dirname = dirname(importMeta.filename);
+            }
+        };
+        if (
+        // v16.2.0+, v14.18.0+: Add support for WHATWG URL object to parentURL parameter.
+        resolveFunStr === "undefined" ||
+            // v20.0.0+, v18.19.0+"" This API now returns a string synchronously instead of a Promise.
+            resolveFunStr.startsWith("async")
+        // enable by --experimental-import-meta-resolve flag
+        ) {
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    const importMetaUrlRequire = {
+                        url: importMeta.url,
+                        require: createRequire(importMeta.url),
+                    };
+                    // note: the parameter types must be explicitly annotated because
+                    // `@types/node` also declares `ImportMeta.resolve`, which makes
+                    // the contextual type an overload set that provides no inference
+                    importMeta.resolve = function resolve(specifier, parentURL = importMeta.url) {
+                        return pathToFileURL((importMetaUrlRequire.url === parentURL
+                            ? importMetaUrlRequire.require
+                            : createRequire(parentURL)).resolve(specifier)).href;
+                    };
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        else {
+            /// native support
+            import_meta_ponyfill_esmodule = (importMeta) => {
+                if (!shimWs.has(importMeta)) {
+                    shimWs.add(importMeta);
+                    commonShim(importMeta);
+                }
+                return importMeta;
+            };
+        }
+        return import_meta_ponyfill_esmodule(importMeta);
+    }));
+defineGlobalPonyfill("import-meta-ponyfill-esmodule", import_meta_ponyfill_esmodule);
+export let import_meta_ponyfill = ((...args) => {
+    const _MODULE = (() => {
+        if (typeof require === "function" && typeof module === "object") {
+            return "commonjs";
+        }
+        else {
+            // eval("typeof import.meta");
+            return "esmodule";
+        }
+    })();
+    if (_MODULE === "commonjs") {
+        //@ts-ignore
+        import_meta_ponyfill = (r, m) => import_meta_ponyfill_commonjs(r, m);
+    }
+    else {
+        //@ts-ignore
+        import_meta_ponyfill = (im) => import_meta_ponyfill_esmodule(im);
+    }
+    //@ts-ignore
+    return import_meta_ponyfill(...args);
+});

package/esm/_dnt.shims.d.ts

@@ -3,4 +3,3 @@ export { Deno } from "@deno/shim-deno";
 export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
     Deno: typeof Deno;
 };
-//# sourceMappingURL=_dnt.shims.d.ts.map

package/esm/anchors/CaptureSink.d.ts

@@ -80,4 +80,3 @@ export declare class CaptureSink {
      */
     observe(producer: SnippetBase, impl: (this: SnippetBase) => string): string;
 }
-//# sourceMappingURL=CaptureSink.d.ts.map

package/esm/anchors/ParserAdapter.d.ts

@@ -92,4 +92,3 @@ export interface ParserAdapter {
         end: number;
     };
 }
-//# sourceMappingURL=ParserAdapter.d.ts.map

package/esm/anchors/attribute.d.ts

@@ -22,4 +22,3 @@ import type { Attribution } from './types.js';
  * key-derived fallback pointer.
  */
 export declare const attribute: (producer: SnippetBase) => Attribution;
-//# sourceMappingURL=attribute.d.ts.map

package/esm/anchors/attribute.js

@@ -54,7 +54,9 @@ export const attribute = (producer) => {
  * - OAS operation → `#/paths/<escaped-path>/<method>`
  * - GQL operation → `<rootKind>.<fieldName>`
  * - Model → `#/components/schemas/<refName>`
- * - Generator-only / no key → `''` (no schema location to point at)
+ * - Container / generator-only / no key → `''` (no schema location to point
+ *   at — a container is a place many subjects insert into, so it has no
+ *   position of its own; its MEMBERS carry their subjects' keys)
  */
 const schemaPointerFromKey = (parsed) => {
     if (!parsed)
@@ -68,6 +70,7 @@ const schemaPointerFromKey = (parsed) => {
             return `${parsed.rootKind}.${parsed.fieldName}`;
         case 'model':
             return `#/components/schemas/${parsed.refName}`;
+        case 'container':
         case 'generator-only':
             return '';
         default: {

package/esm/anchors/buildSidecar.d.ts

@@ -51,4 +51,3 @@ export type BuildSidecarArgs = {
  * export and have no useful re-resolution path (plan #25).
  */
 export declare const buildSidecar: ({ filePath, schemaSrc, parser, anchors }: BuildSidecarArgs) => Sidecar;
-//# sourceMappingURL=buildSidecar.d.ts.map

package/esm/anchors/generationMap.d.ts

@@ -64,4 +64,3 @@ export declare const toNdjson: (entries: readonly GenerationMapEntry[]) => strin
  * unparseable means the file is corrupt, not just stale.
  */
 export declare const parseNdjson: (text: string) => GenerationMapEntry[];
-//# sourceMappingURL=generationMap.d.ts.map

package/esm/anchors/postPass.d.ts

@@ -84,4 +84,3 @@ export type PostPassArgs = {
  * disk, attach to manifest, send over the wire).
  */
 export declare const postPass: ({ filePath, source, spans, schemaSrc, parser, generatorMeta }: PostPassArgs) => Sidecar;
-//# sourceMappingURL=postPass.d.ts.map

package/esm/anchors/sidecar.d.ts

@@ -86,4 +86,3 @@ export type AnchorRow = v.InferOutput<typeof anchorRow>;
  * `buildSidecar`.
  */
 export declare const emptySidecar: (filePath: string, schemaSrc: string, parser: string) => Sidecar;
-//# sourceMappingURL=sidecar.d.ts.map

package/esm/anchors/types.d.ts

@@ -48,4 +48,3 @@ export type Attribution = {
      */
     producerName: string;
 };
-//# sourceMappingURL=types.d.ts.map

package/esm/app/validate.d.ts

@@ -32,4 +32,3 @@
  */
 import "../_dnt.polyfills.js";
 export declare const checkProjectName: (name: string) => string | undefined;
-//# sourceMappingURL=validate.d.ts.map

package/esm/context/CoreContext.d.ts

@@ -406,4 +406,3 @@ export declare function skmtcFormatter({ logRecord, stackTrail }: JsonFormatterA
  */
 export declare function skmtcJsonFormatter({ logRecord, stackTrail }: JsonFormatterArgs): string;
 export {};
-//# sourceMappingURL=CoreContext.d.ts.map

package/esm/context/GenerateContext.d.ts

@@ -4,11 +4,12 @@ import type { OasRef } from '../oas/ref/Ref.js';
 import type { SkmtcParsedDocument } from '../types/SkmtcDocument.js';
 import type { SupportedSubjects } from '../types/SupportedSubjects.js';
 import type { EnrichmentDefaults } from '../types/EnrichmentDefaults.js';
-import type { BuildModelSettingsArgs, GenerateContextType, GenerateResult, InsertModelOptions, InsertNormalizedModelArgs, InsertNormalizedModelOptions, InsertNormalizedModelReturn, InsertOperationArgs, InsertWebhookArgs, PickArgs, ContextRegisterArgs, RegisterJsonArgs, RegisterMarkdownArgs, ToOperationSettingsArgs, ToWebhookSettingsArgs } from './generateTypes.js';
+import type { BuildModelSettingsArgs, GenerateContextType, GenerateResult, InsertModelOptions, InsertNormalizedModelArgs, InsertNormalizedModelOptions, InsertNormalizedModelReturn, InsertOperationArgs, InsertWebhookArgs, FindDefinitionArgs, ContextRegisterArgs, RegisterJsonArgs, RegisterMarkdownArgs, ToOperationSettingsArgs, ToWebhookSettingsArgs } from './generateTypes.js';
 import type { ClientSettings } from '../types/Settings.js';
 import type { Method } from '../types/Method.js';
 import type { OasOperation } from '../oas/operation/Operation.js';
 import type { OasWebhook } from '../oas/webhook/Webhook.js';
+import { type ProjectionOptionsRest } from '../types/ProjectionOptions.js';
 import type { GeneratedValue } from '../dsl/GeneratedValue.js';
 import { ContentSettings } from '../dsl/ContentSettings.js';
 import type { RefName } from '../types/RefName.js';
@@ -254,7 +255,7 @@ export declare class GenerateContext implements GenerateContextType {
      *
      * @mutates this.files
      */
-    register({ imports, reExports, definitions, custom, destinationPath }: ContextRegisterArgs): void;
+    register({ imports, reExports, definitions, custom, destinationPath, into }: ContextRegisterArgs): void;
     /**
      * Insert operation into the output file with path `destinationPath`.
      *
@@ -267,18 +268,18 @@ export declare class GenerateContext implements GenerateContextType {
      *
      * @mutates this.files
      */
-    insertOperation<V extends GeneratedValue, EnrichmentType = undefined>(args: InsertOperationArgs<V, EnrichmentType>): Inserted<V, EnrichmentType>;
+    insertOperation<V extends GeneratedValue, EnrichmentType = undefined, ProjectionOptions = undefined>(args: InsertOperationArgs<V, EnrichmentType, ProjectionOptions>): Inserted<V, EnrichmentType>;
     /**
      * Insert a webhook's projection. Sibling of {@link insertOperation} for
      * the OAS 3.1 webhook subject — webhooks are OAS-only, so there is no
      * protocol discrimination.
      */
-    insertWebhook<V extends GeneratedValue, EnrichmentType = undefined>(args: InsertWebhookArgs<V, EnrichmentType>): Inserted<V, EnrichmentType>;
+    insertWebhook<V extends GeneratedValue, EnrichmentType = undefined, ProjectionOptions = undefined>(args: InsertWebhookArgs<V, EnrichmentType, ProjectionOptions>): Inserted<V, EnrichmentType>;
     /**
      * Insert a normalized model: dispatch to {@link insertModel} when the schema
      * is a `$ref`, otherwise produce a one-off definition under `fallbackName`.
      */
-    insertNormalizedModel<V extends GeneratedValue, Schema extends OasSchema | OasRef<'schema'> | OasVoid, EnrichmentType>(projection: NormalizedModelProjection<V, EnrichmentType>, { schema, fallbackName, destinationPath }: InsertNormalizedModelArgs<Schema>, { noExport, variant }?: InsertNormalizedModelOptions): InsertNormalizedModelReturn<V, Schema>;
+    insertNormalizedModel<V extends GeneratedValue, Schema extends OasSchema | OasRef<'schema'> | OasVoid, EnrichmentType, ProjectionOptions = undefined>(projection: NormalizedModelProjection<V, EnrichmentType, ProjectionOptions>, { schema, fallbackName, destinationPath }: InsertNormalizedModelArgs<Schema>, ...rest: ProjectionOptionsRest<InsertNormalizedModelOptions<ProjectionOptions>, ProjectionOptions>): InsertNormalizedModelReturn<V, Schema>;
     /**
      * Insert a model definition into `destinationPath`.
      *
@@ -288,20 +289,20 @@ export declare class GenerateContext implements GenerateContextType {
      *
      * @mutates this.files
      */
-    insertModel<V extends GeneratedValue, EnrichmentType>(projection: ModelProjection<V, EnrichmentType>, refName: RefName, { destinationPath, noExport, variant }?: InsertModelOptions): Inserted<V, EnrichmentType>;
+    insertModel<V extends GeneratedValue, EnrichmentType, ProjectionOptions = undefined>(projection: ModelProjection<V, EnrichmentType, ProjectionOptions>, refName: RefName, ...rest: ProjectionOptionsRest<InsertModelOptions<ProjectionOptions>, ProjectionOptions>): Inserted<V, EnrichmentType>;
     /**
      * Build content settings for an operation projection by calling its
      * statics `toIdentifierName` + `toIdentifierType`, `toExportPath`, and
      * `toEnrichments` against the
      * given operation.
      */
-    toOperationContentSettings<V extends GeneratedValue, EnrichmentType>(args: ToOperationSettingsArgs<V, EnrichmentType>): ContentSettings<EnrichmentType>;
+    toOperationContentSettings<V extends GeneratedValue, EnrichmentType, ProjectionOptions>(settingsArgs: ToOperationSettingsArgs<V, EnrichmentType, ProjectionOptions>): ContentSettings<EnrichmentType>;
     /**
      * Build content settings for a webhook projection. Sibling of
      * {@link toOperationContentSettings}; webhooks are OAS-only, so there is no
      * protocol discrimination.
      */
-    toWebhookContentSettings<V extends GeneratedValue, EnrichmentType>(args: ToWebhookSettingsArgs<V, EnrichmentType>): ContentSettings<EnrichmentType>;
+    toWebhookContentSettings<V extends GeneratedValue, EnrichmentType, ProjectionOptions>(args: ToWebhookSettingsArgs<V, EnrichmentType, ProjectionOptions>): ContentSettings<EnrichmentType>;
     /**
      * Build content settings for a model projection by calling its statics
      * `toIdentifierName` (pure, for the name) + `toIdentifierType`
@@ -310,7 +311,7 @@ export declare class GenerateContext implements GenerateContextType {
      * identifier is assembled through the projection's language
      * (`lang.toIdentifier`).
      */
-    toModelContentSettings<V extends GeneratedValue, EnrichmentType>({ refName, projection, variant }: BuildModelSettingsArgs<V, EnrichmentType>): ContentSettings<EnrichmentType>;
+    toModelContentSettings<V extends GeneratedValue, EnrichmentType, ProjectionOptions>(args: BuildModelSettingsArgs<V, EnrichmentType, ProjectionOptions>): ContentSettings<EnrichmentType>;
     /**
      * Perform one lookup of schema by `refName`.
      * @param refName
@@ -325,7 +326,7 @@ export declare class GenerateContext implements GenerateContextType {
      * @param { name, exportPath }
      * @returns Matching definition if found or `undefined` otherwise
      */
-    findDefinition({ name, exportPath }: PickArgs): DefinitionBase | undefined;
+    findDefinition({ name, exportPath, into }: FindDefinitionArgs): DefinitionBase | undefined;
 }
 type ToOasOperationSourceArgs = {
     operation: OasOperation;
@@ -384,4 +385,3 @@ type ToModelSourceArgs = {
  */
 export declare const toModelSource: ({ refName, generatorId, variant }: ToModelSourceArgs) => ModelSource;
 export {};
-//# sourceMappingURL=GenerateContext.d.ts.map