@skmtc/core 0.0.984 → 0.16.2

package/script/gql/registry/GqlRegistry.d.ts

@@ -0,0 +1,70 @@
+import type { OasSchema } from '../../oas/schema/Schema.js';
+import { OasRef } from '../../oas/ref/Ref.js';
+import type { RefName } from '../../types/RefName.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+/**
+ * Fields used to construct a {@link GqlRegistry}.
+ */
+export type GqlRegistryFields = {
+    /**
+     * Initial set of named-type entries. The registry holds a live reference
+     * to this record — additions made via {@link GqlRegistry.add} are visible
+     * to anything that reads `registry.schemas` later.
+     */
+    schemas?: Record<RefName, OasSchema | OasRef<'schema'>>;
+};
+/**
+ * The named-type registry for a {@link GqlDocument}.
+ *
+ * `GqlRegistry` mirrors the schemas bucket of `OasComponents` — it is the
+ * registry side of the lingua franca that both protocols share. Model
+ * generators read from it via the discriminated dispatch in
+ * `GenerateContext`.
+ *
+ * Refs resolve through the parent {@link GqlDocument} via
+ * {@link SkmtcParsedDocument}'s GQL variant — no fake `OasDocument`
+ * mirror needed. `createRef` takes the document at call time so the
+ * resulting `OasRef` points at the same instance that will eventually
+ * carry the populated registry. See the forward-declared-refs notes on
+ * `OasDocument` / `GqlDocument` for why the document must exist (empty)
+ * before any ref is constructed.
+ */
+export declare class GqlRegistry {
+    readonly schemas: Record<RefName, OasSchema | OasRef<'schema'>>;
+    constructor(fields?: GqlRegistryFields);
+    /**
+     * Returns all RefNames currently registered, in insertion order.
+     *
+     * Mirrors `OasComponents.toSchemasRefNames()` so model generators can
+     * iterate the registry uniformly across protocols.
+     */
+    toSchemasRefNames(): RefName[];
+    /**
+     * Adds (or replaces) a schema entry under `refName`.
+     *
+     * The mutation is visible to any previously constructed `OasRef` that
+     * resolves through this registry, because resolution reads through the
+     * shared `schemas` record by reference.
+     */
+    add(refName: RefName, schema: OasSchema | OasRef<'schema'>): void;
+    /**
+     * Returns true if `refName` is currently registered.
+     */
+    has(refName: RefName): boolean;
+    /**
+     * Constructs an `OasRef<'schema'>` that resolves to the entry registered
+     * under `refName`. Use this to build cross-type references during
+     * GraphQL parsing instead of constructing `OasRef` directly.
+     *
+     * The ref resolves through the context's `parsedDocument` (the parent
+     * `GqlDocument` wrapped as `SkmtcParsedDocument`). The document can be
+     * empty-at-construction; the ref resolves correctly once the document's
+     * fields are populated at the end of parsing.
+     */
+    createRef(refName: RefName, context: ParseContextType): OasRef<'schema'>;
+    /**
+     * Removes a schema entry by name. Returns `true` if removed.
+     */
+    removeSchema(refName: RefName): boolean;
+}
+//# sourceMappingURL=GqlRegistry.d.ts.map

package/script/gql/registry/GqlRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GqlRegistry.d.ts","sourceRoot":"","sources":["../../../src/gql/registry/GqlRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAA;CACxD,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,WAAW;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAA;gBAEnD,MAAM,GAAE,iBAAsB;IAI1C;;;;;OAKG;IACH,iBAAiB,IAAI,OAAO,EAAE;IAI9B;;;;;;OAMG;IACH,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,IAAI;IAIjE;;OAEG;IACH,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;IAI9B;;;;;;;;;OASG;IACH,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,GAAG,MAAM,CAAC,QAAQ,CAAC;IAOxE;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO;CAOxC"}

package/script/gql/registry/GqlRegistry.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GqlRegistry = void 0;
+const Ref_js_1 = require("../../oas/ref/Ref.js");
+/**
+ * The named-type registry for a {@link GqlDocument}.
+ *
+ * `GqlRegistry` mirrors the schemas bucket of `OasComponents` — it is the
+ * registry side of the lingua franca that both protocols share. Model
+ * generators read from it via the discriminated dispatch in
+ * `GenerateContext`.
+ *
+ * Refs resolve through the parent {@link GqlDocument} via
+ * {@link SkmtcParsedDocument}'s GQL variant — no fake `OasDocument`
+ * mirror needed. `createRef` takes the document at call time so the
+ * resulting `OasRef` points at the same instance that will eventually
+ * carry the populated registry. See the forward-declared-refs notes on
+ * `OasDocument` / `GqlDocument` for why the document must exist (empty)
+ * before any ref is constructed.
+ */
+class GqlRegistry {
+    constructor(fields = {}) {
+        Object.defineProperty(this, "schemas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.schemas = fields.schemas ?? {};
+    }
+    /**
+     * Returns all RefNames currently registered, in insertion order.
+     *
+     * Mirrors `OasComponents.toSchemasRefNames()` so model generators can
+     * iterate the registry uniformly across protocols.
+     */
+    toSchemasRefNames() {
+        return Object.keys(this.schemas);
+    }
+    /**
+     * Adds (or replaces) a schema entry under `refName`.
+     *
+     * The mutation is visible to any previously constructed `OasRef` that
+     * resolves through this registry, because resolution reads through the
+     * shared `schemas` record by reference.
+     */
+    add(refName, schema) {
+        this.schemas[refName] = schema;
+    }
+    /**
+     * Returns true if `refName` is currently registered.
+     */
+    has(refName) {
+        return refName in this.schemas;
+    }
+    /**
+     * Constructs an `OasRef<'schema'>` that resolves to the entry registered
+     * under `refName`. Use this to build cross-type references during
+     * GraphQL parsing instead of constructing `OasRef` directly.
+     *
+     * The ref resolves through the context's `parsedDocument` (the parent
+     * `GqlDocument` wrapped as `SkmtcParsedDocument`). The document can be
+     * empty-at-construction; the ref resolves correctly once the document's
+     * fields are populated at the end of parsing.
+     */
+    createRef(refName, context) {
+        return new Ref_js_1.OasRef({ refType: 'schema', $ref: `#/components/schemas/${refName}` }, context);
+    }
+    /**
+     * Removes a schema entry by name. Returns `true` if removed.
+     */
+    removeSchema(refName) {
+        if (refName in this.schemas) {
+            delete this.schemas[refName];
+            return true;
+        }
+        return false;
+    }
+}
+exports.GqlRegistry = GqlRegistry;

package/script/gql/rootType/GqlRootTypes.d.ts

@@ -0,0 +1,15 @@
+import type { RefName } from '../../types/RefName.js';
+/**
+ * Names of the root operation types declared by a GraphQL schema.
+ *
+ * Defaults are `Query`, `Mutation`, and `Subscription` but a schema may
+ * override any of them via `schema { query: Foo, mutation: Bar }`. Each
+ * field, when set, is a {@link RefName} into the document's
+ * {@link GqlRegistry}.
+ */
+export type GqlRootTypes = {
+    query?: RefName;
+    mutation?: RefName;
+    subscription?: RefName;
+};
+//# sourceMappingURL=GqlRootTypes.d.ts.map

package/script/gql/rootType/GqlRootTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GqlRootTypes.d.ts","sourceRoot":"","sources":["../../../src/gql/rootType/GqlRootTypes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAErD;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA"}

package/script/gql/rootType/GqlRootTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/gql/scalar/toScalarType.d.ts

@@ -0,0 +1,33 @@
+import type { GraphQLScalarType } from 'graphql';
+import type { OasSchema } from '../../oas/schema/Schema.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+import type { StackTrail } from '../../context/StackTrail.js';
+export type ToScalarTypeArgs = {
+    scalar: GraphQLScalarType;
+    nullable: boolean;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+/**
+ * Maps a GraphQL scalar to an `OasSchema` primitive.
+ *
+ * Built-in GraphQL scalars map to their natural OAS counterparts:
+ * - `Int`     → `OasInteger` (`format: 'int32'`)
+ * - `Float`   → `OasNumber`  (`format: 'float'`)
+ * - `String`  → `OasString`
+ * - `Boolean` → `OasBoolean`
+ * - `ID`      → `OasString` with `format: 'id'` so generators that want
+ *               to treat IDs specially can narrow on the format key.
+ *
+ * Custom scalars (everything else) become `OasString` with
+ * `format: '<scalarName>'`. Downstream generators (`gen-typescript`,
+ * `gen-zod`, etc.) consult their own `scalars` config map keyed on the
+ * format string to decide the actual emitted type.
+ *
+ * `context` and `stackTrail` are accepted (and currently unused) so the
+ * signature matches the OAS parser family; future error reporting on
+ * unknown scalars or constraint conflicts can flow through `context`
+ * without an API change.
+ */
+export declare const toScalarType: ({ scalar, nullable, context, stackTrail }: ToScalarTypeArgs) => OasSchema;
+//# sourceMappingURL=toScalarType.d.ts.map

package/script/gql/scalar/toScalarType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toScalarType.d.ts","sourceRoot":"","sources":["../../../src/gql/scalar/toScalarType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAKhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAE7D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,iBAAiB,CAAA;IACzB,QAAQ,EAAE,OAAO,CAAA;IACjB,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,YAAY,GAAI,2CAK1B,gBAAgB,KAAG,SAkBlB,CAAA"}

package/script/gql/scalar/toScalarType.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toScalarType = void 0;
+const String_js_1 = require("../../oas/string/String.js");
+const Integer_js_1 = require("../../oas/integer/Integer.js");
+const Number_js_1 = require("../../oas/number/Number.js");
+const Boolean_js_1 = require("../../oas/boolean/Boolean.js");
+/**
+ * Maps a GraphQL scalar to an `OasSchema` primitive.
+ *
+ * Built-in GraphQL scalars map to their natural OAS counterparts:
+ * - `Int`     → `OasInteger` (`format: 'int32'`)
+ * - `Float`   → `OasNumber`  (`format: 'float'`)
+ * - `String`  → `OasString`
+ * - `Boolean` → `OasBoolean`
+ * - `ID`      → `OasString` with `format: 'id'` so generators that want
+ *               to treat IDs specially can narrow on the format key.
+ *
+ * Custom scalars (everything else) become `OasString` with
+ * `format: '<scalarName>'`. Downstream generators (`gen-typescript`,
+ * `gen-zod`, etc.) consult their own `scalars` config map keyed on the
+ * format string to decide the actual emitted type.
+ *
+ * `context` and `stackTrail` are accepted (and currently unused) so the
+ * signature matches the OAS parser family; future error reporting on
+ * unknown scalars or constraint conflicts can flow through `context`
+ * without an API change.
+ */
+const toScalarType = ({ scalar, nullable, context, stackTrail }) => context.withStackTrail(stackTrail, () => {
+    switch (scalar.name) {
+        case 'Int':
+            return new Integer_js_1.OasInteger({ format: 'int32', nullable }, context);
+        case 'Float':
+            return new Number_js_1.OasNumber({ format: 'float', nullable }, context);
+        case 'String':
+            return new String_js_1.OasString({ nullable }, context);
+        case 'Boolean':
+            return new Boolean_js_1.OasBoolean({ nullable }, context);
+        case 'ID':
+            return new String_js_1.OasString({ format: 'id', nullable }, context);
+        default:
+            // Custom scalar — preserve the scalar name as `format` so downstream
+            // generators can map it via their `scalars` config.
+            return new String_js_1.OasString({ format: scalar.name, nullable }, context);
+    }
+});
+exports.toScalarType = toScalarType;

package/script/gql/union/toUnionType.d.ts

@@ -0,0 +1,24 @@
+import type { GraphQLUnionType } from 'graphql';
+import { OasUnion } from '../../oas/union/Union.js';
+import type { ParseContextType } from '../../context/parseTypes.js';
+import type { StackTrail } from '../../context/StackTrail.js';
+export type ToUnionTypeArgs = {
+    unionType: GraphQLUnionType;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+/**
+ * Converts a GraphQL union type into an `OasUnion` over refs to its
+ * member types.
+ *
+ * GraphQL unions are always discriminated by `__typename` at the wire
+ * level, so we record that discriminator on the union. Generators that
+ * emit discriminated TS unions can read it; generators that don't care
+ * about discrimination ignore it.
+ *
+ * Each member ref records the consumer location via `registerRef` so
+ * if a member type fails to parse, the union's reference to it can be
+ * pruned at the end of parsing.
+ */
+export declare const toUnionType: ({ unionType, context, stackTrail }: ToUnionTypeArgs) => OasUnion;
+//# sourceMappingURL=toUnionType.d.ts.map

package/script/gql/union/toUnionType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toUnionType.d.ts","sourceRoot":"","sources":["../../../src/gql/union/toUnionType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAKnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAA;AAE7D,MAAM,MAAM,eAAe,GAAG;IAC5B,SAAS,EAAE,gBAAgB,CAAA;IAC3B,OAAO,EAAE,gBAAgB,CAAA;IACzB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAI,oCAIzB,eAAe,KAAG,QAuBpB,CAAA"}

package/script/gql/union/toUnionType.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toUnionType = void 0;
+const Union_js_1 = require("../../oas/union/Union.js");
+const Discriminator_js_1 = require("../../oas/discriminator/Discriminator.js");
+const recordAppliedDirectives_js_1 = require("../_helpers/recordAppliedDirectives.js");
+/**
+ * Converts a GraphQL union type into an `OasUnion` over refs to its
+ * member types.
+ *
+ * GraphQL unions are always discriminated by `__typename` at the wire
+ * level, so we record that discriminator on the union. Generators that
+ * emit discriminated TS unions can read it; generators that don't care
+ * about discrimination ignore it.
+ *
+ * Each member ref records the consumer location via `registerRef` so
+ * if a member type fails to parse, the union's reference to it can be
+ * pruned at the end of parsing.
+ */
+const toUnionType = ({ unionType, context, stackTrail }) => {
+    (0, recordAppliedDirectives_js_1.recordAppliedDirectives)({ astNode: unionType.astNode, stackTrail, context });
+    const members = stackTrail.trace('members', membersStack => unionType.getTypes().map((member, index) => membersStack.trace(String(index), memberStack => {
+        context.registerRef(memberStack.clone(), member.name);
+        return context.registry.createRef(member.name, context);
+    })));
+    return context.withStackTrail(stackTrail, () => new Union_js_1.OasUnion({
+        title: unionType.name,
+        description: unionType.description ?? undefined,
+        members,
+        discriminator: new Discriminator_js_1.OasDiscriminator({ propertyName: '__typename' })
+    }, context));
+};
+exports.toUnionType = toUnionType;

package/script/helpers/collateExamples.d.ts

@@ -1,3 +1,4 @@
+import "../_dnt.polyfills.js";
 import type { OasRef } from '../oas/ref/Ref.js';
 import type { OasSchema } from '../oas/schema/Schema.js';
 /**

package/script/helpers/collateExamples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collateExamples.d.ts","sourceRoot":"","sources":["../../src/helpers/collateExamples.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGxD;;GAEG;AACH,KAAK,mBAAmB,GAAG;IACzB,+DAA+D;IAC/D,YAAY,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA;IACtD,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgJG;AACH,eAAO,MAAM,eAAe,GAAI,yBAAyB,mBAAmB,KAAG,OAyF9E,CAAA"}
+{"version":3,"file":"collateExamples.d.ts","sourceRoot":"","sources":["../../src/helpers/collateExamples.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGxD;;GAEG;AACH,KAAK,mBAAmB,GAAG;IACzB,+DAA+D;IAC/D,YAAY,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA;IACtD,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgJG;AACH,eAAO,MAAM,eAAe,GAAI,yBAAyB,mBAAmB,KAAG,OAyF9E,CAAA"}

package/script/helpers/collateExamples.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collateExamples = void 0;
+require("../_dnt.polyfills.js");
 const isEmpty_js_1 = require("./isEmpty.js");
 /**
  * Recursively collates and builds example values from OpenAPI schemas.

package/script/helpers/formatNumber.d.ts

@@ -93,5 +93,6 @@
  * // Japanese: 50,000
  * ```
  */
+import "../_dnt.polyfills.js";
 export declare const formatNumber: (value: number, locales?: Intl.LocalesArgument) => string;
 //# sourceMappingURL=formatNumber.d.ts.map

package/script/helpers/formatNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatNumber.d.ts","sourceRoot":"","sources":["../../src/helpers/formatNumber.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8FG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,EAAE,UAAS,IAAI,CAAC,eAAyB,KAAG,MAKrF,CAAA"}
+{"version":3,"file":"formatNumber.d.ts","sourceRoot":"","sources":["../../src/helpers/formatNumber.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8FG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,YAAY,GAAI,OAAO,MAAM,EAAE,UAAS,IAAI,CAAC,eAAyB,KAAG,MAKrF,CAAA"}

package/script/helpers/formatNumber.js

@@ -96,6 +96,7 @@ exports.formatNumber = void 0;
  * // Japanese: 50,000
  * ```
  */
+require("../_dnt.polyfills.js");
 const formatNumber = (value, locales = 'en-US') => {
     return value.toLocaleString(locales, {
         minimumFractionDigits: 0,

package/script/helpers/isEmpty.d.ts

@@ -1,5 +1,6 @@
 /**
  * Checks whether a record/object is empty (has no enumerable properties).
  */
+import "../_dnt.polyfills.js";
 export declare const isEmpty: (value: object) => boolean;
 //# sourceMappingURL=isEmpty.d.ts.map

package/script/helpers/isEmpty.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isEmpty.d.ts","sourceRoot":"","sources":["../../src/helpers/isEmpty.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,OAAO,GAAI,OAAO,MAAM,KAAG,OAEvC,CAAA"}
+{"version":3,"file":"isEmpty.d.ts","sourceRoot":"","sources":["../../src/helpers/isEmpty.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,OAAO,GAAI,OAAO,MAAM,KAAG,OAEvC,CAAA"}

package/script/helpers/isEmpty.js

@@ -4,6 +4,7 @@ exports.isEmpty = void 0;
 /**
  * Checks whether a record/object is empty (has no enumerable properties).
  */
+require("../_dnt.polyfills.js");
 const isEmpty = (value) => {
     return !Object.keys(value).length;
 };

package/script/helpers/isImported.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isImported = void 0;
-const normalize_js_1 = require("../deps/jsr.io/@std/path/1.1.3/normalize.js");
+const normalize_js_1 = require("../deps/jsr.io/@std/path/1.1.4/normalize.js");
 /**
  * Determines whether two file paths represent different locations (import required).
  *

package/script/helpers/refFns.d.ts

@@ -1,6 +1,7 @@
+import "../_dnt.polyfills.js";
 import type { RefName } from '../types/RefName.js';
 import type { OpenAPIV3 } from 'openapi-types';
-import type { ReferenceObject } from '../oas/_merge-all-of/types.js';
+import type { ReferenceObject } from '../parse/v3-0/_merge-all-of/types.js';
 /**
  * Extracts a reference name from an OpenAPI $ref string.
  *

package/script/helpers/refFns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"refFns.d.ts","sourceRoot":"","sources":["../../src/helpers/refFns.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,KAAG,OASxC,CAAA;AAED;;GAEG;AACH,KAAK,GAAG,GAAG;IACT,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,GAM/C,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,eAAO,MAAM,QAAQ,GAClB,aAAa,SAAS,CAAC,QAAQ,MAC/B,UAAU,eAAe,KAAG,SAAS,CAAC,YActC,CAAA"}
+{"version":3,"file":"refFns.d.ts","sourceRoot":"","sources":["../../src/helpers/refFns.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sCAAsC,CAAA;AAE3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,KAAG,OASxC,CAAA;AAED;;GAEG;AACH,KAAK,GAAG,GAAG;IACT,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,GAM/C,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,eAAO,MAAM,QAAQ,GAClB,aAAa,SAAS,CAAC,QAAQ,MAC/B,UAAU,eAAe,KAAG,SAAS,CAAC,YActC,CAAA"}

package/script/helpers/refFns.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toGetRef = exports.isRef = exports.toRefName = void 0;
+require("../_dnt.polyfills.js");
 /**
  * Extracts a reference name from an OpenAPI $ref string.
  *

package/script/helpers/strings.d.ts

@@ -55,6 +55,7 @@
  * capitalize(''); // ''
  * ```
  */
+import "../_dnt.polyfills.js";
 export declare const capitalize: (str: string) => string;
 /**
  * Decapitalizes (lowercases) the first character of a string.

package/script/helpers/strings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/helpers/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MAExC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAE1C,CAAA;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,oCAAmC,gBAAqB,KAAG,MA+BjG,CAAA"}
+{"version":3,"file":"strings.d.ts","sourceRoot":"","sources":["../../src/helpers/strings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;GAYG;AACH,OAAO,sBAAsB,CAAC;AAE9B,eAAO,MAAM,UAAU,GAAI,KAAK,MAAM,KAAG,MAExC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,KAAK,MAAM,KAAG,MAE1C,CAAA;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG;IACtB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,oCAAmC,gBAAqB,KAAG,MA+BjG,CAAA"}

package/script/helpers/strings.js

@@ -58,6 +58,7 @@ exports.camelCase = exports.decapitalize = exports.capitalize = void 0;
  * capitalize(''); // ''
  * ```
  */
+require("../_dnt.polyfills.js");
 const capitalize = (str) => {
     return str.charAt(0).toUpperCase() + str.slice(1);
 };

package/script/helpers/toResolvedArtifactPath.d.ts

@@ -59,6 +59,7 @@
  *
  * @module toResolvedArtifactPath
  */
+import "../_dnt.polyfills.js";
 /**
  * Arguments for resolving artifact file paths.
  *

package/script/helpers/toResolvedArtifactPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toResolvedArtifactPath.d.ts","sourceRoot":"","sources":["../../src/helpers/toResolvedArtifactPath.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AAIH;;;;;GAKG;AACH,KAAK,0BAA0B,GAAG;IAChC,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,iDAAiD;IACjD,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2IG;AACH,eAAO,MAAM,sBAAsB,GAAI,+BAGpC,0BAA0B,KAAG,MAE/B,CAAA"}
+{"version":3,"file":"toResolvedArtifactPath.d.ts","sourceRoot":"","sources":["../../src/helpers/toResolvedArtifactPath.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,OAAO,sBAAsB,CAAC;AAK9B;;;;;GAKG;AACH,KAAK,0BAA0B,GAAG;IAChC,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,iDAAiD;IACjD,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2IG;AACH,eAAO,MAAM,sBAAsB,GAAI,+BAGpC,0BAA0B,KAAG,MAE/B,CAAA"}

package/script/helpers/toResolvedArtifactPath.js

@@ -1,4 +1,6 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toResolvedArtifactPath = void 0;
 /**
  * @fileoverview Artifact Path Resolution Utilities for SKMTC Core
  *
@@ -60,9 +62,8 @@
  *
  * @module toResolvedArtifactPath
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toResolvedArtifactPath = void 0;
-const join_js_1 = require("../deps/jsr.io/@std/path/1.1.3/join.js");
+require("../_dnt.polyfills.js");
+const join_js_1 = require("../deps/jsr.io/@std/path/1.1.4/join.js");
 /**
  * Resolves artifact destination paths relative to a base directory.
  *

package/script/helpers/toVariantList.d.ts

@@ -0,0 +1,32 @@
+type ToVariantListArgs = {
+    /**
+     * The enrichment block at `[generatorId][path][method]` (OAS) or
+     * `[generatorId][rootKind][fieldName]` (GQL). Typed as `unknown`
+     * because `lodash-es/get()` returns `unknown` and the engine
+     * doesn't pre-validate this branch.
+     */
+    opEnrichments: unknown;
+    generatorId: string;
+    /**
+     * Human-readable identifier for the operation used in the
+     * missing-`main` error message — e.g. `'PATCH /v2/quotes/{id}'` for
+     * OAS or `'mutation createUser'` for GraphQL.
+     */
+    operationLabel: string;
+};
+/**
+ * Enumerate the operation variants the engine should fan out over.
+ *
+ * - No enrichment block → `['main']` (consumer skipped this generator
+ *   entirely, or wrote no per-operation overrides).
+ * - Non-object enrichment block → `['main']` (defensive — Valibot at
+ *   parse time will catch this once the per-variant wrap lands).
+ * - Empty-object enrichment block → `['main']` (no consumer-named
+ *   variants, fall back to default).
+ * - Object enrichment block with keys → its keys, in JSON-insertion
+ *   order. `'main'` must be among them or we throw — silent
+ *   zero-output downstream is the worse failure mode.
+ */
+export declare const toVariantList: ({ opEnrichments, generatorId, operationLabel }: ToVariantListArgs) => string[];
+export {};
+//# sourceMappingURL=toVariantList.d.ts.map

package/script/helpers/toVariantList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toVariantList.d.ts","sourceRoot":"","sources":["../../src/helpers/toVariantList.ts"],"names":[],"mappings":"AAEA,KAAK,iBAAiB,GAAG;IACvB;;;;;OAKG;IACH,aAAa,EAAE,OAAO,CAAA;IACtB,WAAW,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,GAAI,gDAI3B,iBAAiB,KAAG,MAAM,EAuB5B,CAAA"}

package/script/helpers/toVariantList.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toVariantList = void 0;
+const Variant_js_1 = require("../types/Variant.js");
+/**
+ * Enumerate the operation variants the engine should fan out over.
+ *
+ * - No enrichment block → `['main']` (consumer skipped this generator
+ *   entirely, or wrote no per-operation overrides).
+ * - Non-object enrichment block → `['main']` (defensive — Valibot at
+ *   parse time will catch this once the per-variant wrap lands).
+ * - Empty-object enrichment block → `['main']` (no consumer-named
+ *   variants, fall back to default).
+ * - Object enrichment block with keys → its keys, in JSON-insertion
+ *   order. `'main'` must be among them or we throw — silent
+ *   zero-output downstream is the worse failure mode.
+ */
+const toVariantList = ({ opEnrichments, generatorId, operationLabel }) => {
+    if (opEnrichments === null || opEnrichments === undefined) {
+        return [Variant_js_1.DEFAULT_VARIANT];
+    }
+    if (typeof opEnrichments !== 'object' || Array.isArray(opEnrichments)) {
+        return [Variant_js_1.DEFAULT_VARIANT];
+    }
+    const keys = Object.keys(opEnrichments);
+    if (keys.length === 0) {
+        return [Variant_js_1.DEFAULT_VARIANT];
+    }
+    if (!keys.includes(Variant_js_1.DEFAULT_VARIANT)) {
+        throw new Error(`[${generatorId}] Enrichments for '${operationLabel}' must include a ` +
+            `'${Variant_js_1.DEFAULT_VARIANT}' variant. Found variants: ${keys.join(', ')}.`);
+    }
+    return keys;
+};
+exports.toVariantList = toVariantList;

package/script/helpers/withVariant.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Suffix a base identifier name with a variant name.
+ *
+ * For the canonical `'main'` variant, returns the base name unchanged —
+ * variants-aware generators stay name-compatible with variants-unaware
+ * callers for the common single-variant case.
+ *
+ * For any other variant, splits on `-` (kebab-case segments — see
+ * {@link variantNameRegex}), PascalCases each segment, and appends.
+ * The kebab → PascalCase transform is invertible because the variant
+ * regex bans uppercase, so `'line-items'` is the only valid input that
+ * yields `'LineItems'`.
+ *
+ * @example
+ *   withVariant('EditQuotesForm', 'main')         // → 'EditQuotesForm'
+ *   withVariant('EditQuotesForm', 'description')  // → 'EditQuotesFormDescription'
+ *   withVariant('EditQuotesForm', 'line-items')   // → 'EditQuotesFormLineItems'
+ */
+export declare const withVariant: (baseName: string, variant: string) => string;
+//# sourceMappingURL=withVariant.d.ts.map

package/script/helpers/withVariant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withVariant.d.ts","sourceRoot":"","sources":["../../src/helpers/withVariant.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,WAAW,GAAI,UAAU,MAAM,EAAE,SAAS,MAAM,KAAG,MAQ/D,CAAA"}

package/script/helpers/withVariant.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withVariant = void 0;
+const strings_js_1 = require("./strings.js");
+const Variant_js_1 = require("../types/Variant.js");
+/**
+ * Suffix a base identifier name with a variant name.
+ *
+ * For the canonical `'main'` variant, returns the base name unchanged —
+ * variants-aware generators stay name-compatible with variants-unaware
+ * callers for the common single-variant case.
+ *
+ * For any other variant, splits on `-` (kebab-case segments — see
+ * {@link variantNameRegex}), PascalCases each segment, and appends.
+ * The kebab → PascalCase transform is invertible because the variant
+ * regex bans uppercase, so `'line-items'` is the only valid input that
+ * yields `'LineItems'`.
+ *
+ * @example
+ *   withVariant('EditQuotesForm', 'main')         // → 'EditQuotesForm'
+ *   withVariant('EditQuotesForm', 'description')  // → 'EditQuotesFormDescription'
+ *   withVariant('EditQuotesForm', 'line-items')   // → 'EditQuotesFormLineItems'
+ */
+const withVariant = (baseName, variant) => {
+    if (variant === Variant_js_1.DEFAULT_VARIANT) {
+        return baseName;
+    }
+    const suffix = variant.split('-').map(strings_js_1.capitalize).join('');
+    return `${baseName}${suffix}`;
+};
+exports.withVariant = withVariant;