@skmtc/core 0.0.984 → 0.16.2

package/esm/dsl/operation/OperationDriver.js

@@ -1,191 +0,0 @@
-import { normalize } from '../../deps/jsr.io/@std/path/1.1.3/normalize.js';
-import { Definition } from '../Definition.js';
-import { toOperationGeneratorKey } from '../GeneratorKeys.js';
-/**
- * Driver class for generating operation-based artifacts from OpenAPI operations.
- *
- * The `OperationDriver` manages the transformation of OpenAPI operation objects
- * into code artifacts, handling path generation, identifier resolution, and
- * definition management. It serves as the core orchestrator for operation-based
- * code generation in the SKMTC pipeline.
- *
- * @template V - Type of generated values produced by this driver
- * @template T - Type of generation strategy (e.g., 'function', 'class', 'hook')
- * @template EnrichmentType - Type of enrichments that can be applied
- *
- * @example Basic usage in an operation generator
- * ```typescript
- * class APIClientGenerator extends OperationBase {
- *   generate() {
- *     const driver = new OperationDriver({
- *       context: this.context,
- *       insertable: this,
- *       operation: this.operation,
- *       generation: 'function'
- *     });
- *
- *     const functionCode = driver.definition.toValueString();
- *     const file = this.createFile(functionCode);
- *     this.register({ file });
- *   }
- * }
- * ```
- */
-export class OperationDriver {
-    /**
-     * Creates a new OperationDriver instance.
-     *
-     * @param args - Configuration for the operation driver
-     * @param args.context - Generation context
-     * @param args.insertable - Insertable providing generation configuration
-     * @param args.operation - OpenAPI operation to process
-     * @param args.destinationPath - Optional custom destination path
-     * @param args.noExport - Whether to exclude from exports
-     */
-    constructor({ context, insertable, operation, destinationPath, noExport }) {
-        /** The generation context providing access to OAS objects and utilities */
-        Object.defineProperty(this, "context", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** The insertable object that provides generation configuration */
-        Object.defineProperty(this, "insertable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** The OpenAPI operation object being processed */
-        Object.defineProperty(this, "operation", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** Content settings for customizing generation behavior */
-        Object.defineProperty(this, "settings", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** Optional custom destination path for generated files */
-        Object.defineProperty(this, "destinationPath", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** The generated definition containing the transformed operation */
-        Object.defineProperty(this, "definition", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** Whether to exclude this operation from exports */
-        Object.defineProperty(this, "noExport", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.context = context;
-        this.insertable = insertable;
-        this.operation = operation;
-        this.destinationPath = destinationPath;
-        this.noExport = noExport;
-        this.settings = this.context.toOperationContentSettings({
-            operation,
-            insertable
-        });
-        this.definition = this.apply({ destinationPath });
-    }
-    /**
-     * Applies generation configuration to create the operation definition.
-     *
-     * This method handles the core generation logic for operations, including
-     * identifier resolution, export path management, and import registration
-     * for cross-file dependencies.
-     *
-     * @template T - The generation type
-     * @param args - Apply configuration arguments
-     * @param args.generation - Optional generation type (unused currently)
-     * @param args.destinationPath - Optional destination path for imports
-     * @returns Generated definition for the operation
-     */
-    apply({ destinationPath } = {}) {
-        const { identifier, exportPath } = this.settings;
-        const definition = this.getDefinition({ identifier, exportPath });
-        if (destinationPath && normalize(exportPath) !== normalize(destinationPath)) {
-            this.context.register({
-                imports: { [exportPath]: [identifier.name] },
-                destinationPath
-            });
-        }
-        return definition;
-    }
-    /**
-     * Retrieves or creates a definition for the operation.
-     *
-     * This method first checks for cached definitions to avoid duplicate generation,
-     * then creates a new definition if none exists. It handles the complete operation
-     * transformation process including schema resolution and value generation.
-     *
-     * @param args - Definition retrieval arguments
-     * @param args.identifier - The identifier for the definition
-     * @param args.exportPath - The export path for the definition
-     * @returns Operation definition instance
-     */
-    getDefinition({ identifier, exportPath }) {
-        const cachedDefinition = this.context.findDefinition({
-            name: identifier.name,
-            exportPath
-        });
-        if (this.affirmDefinition(cachedDefinition, exportPath)) {
-            return cachedDefinition;
-        }
-        const value = new this.insertable({
-            context: this.context,
-            operation: this.operation,
-            settings: this.settings
-        });
-        const definition = new Definition({
-            context: this.context,
-            value,
-            identifier,
-            noExport: this.noExport
-        });
-        this.context.register({
-            definitions: [definition],
-            destinationPath: exportPath
-        });
-        return definition;
-    }
-    /**
-     * Type guard to verify a definition matches the expected generated value type.
-     *
-     * This method performs type narrowing to ensure a cached definition is compatible
-     * with the current generation requirements, including export path validation.
-     *
-     * @template V - The expected generated value type
-     * @param definition - The definition to verify (may be undefined)
-     * @param exportPath - Expected export path for validation
-     * @returns True if definition matches expected type and constraints
-     */
-    affirmDefinition(definition, exportPath) {
-        if (!definition) {
-            return false;
-        }
-        const currentKey = toOperationGeneratorKey({
-            generatorId: this.insertable.id,
-            operation: this.operation
-        });
-        if (currentKey !== definition.generatorKey) {
-            throw new Error(`Registered definition mismatch: '${definition.identifier.name}' in file '${exportPath}'. Cached key '${definition.generatorKey}' does not match new key '${currentKey}'`);
-        }
-        return definition.value instanceof this.insertable;
-    }
-}

package/esm/dsl/operation/toOperationBase.d.ts

@@ -1,94 +0,0 @@
-import type { GenerateContextType } from '../../context/generateTypes.js';
-import type { OasOperation } from '../../oas/operation/Operation.js';
-import type { Identifier } from '../Identifier.js';
-import type { OperationInsertableArgs } from './types.js';
-import * as v from 'valibot';
-/**
- * Configuration for creating a base operation class.
- *
- * Defines the structure and behavior for operation generators, including
- * identifier generation, export path resolution, and enrichment schemas.
- *
- * @template EnrichmentType - Type of enrichments to apply to generated operations
- */
-export type BaseOperationConfig<EnrichmentType = undefined> = {
-    /** Unique identifier for the operation generator */
-    id: string;
-    /** Function to generate identifiers from operations */
-    toIdentifier: (operation: OasOperation) => Identifier;
-    /** Function to generate export paths from operations */
-    toExportPath: (operation: OasOperation) => string;
-    /** Optional function to provide enrichment validation schema */
-    toEnrichmentSchema?: () => v.BaseSchema<EnrichmentType, EnrichmentType, v.BaseIssue<unknown>>;
-};
-type ToEnrichmentsArgs = {
-    operation: OasOperation;
-    context: GenerateContextType;
-};
-/**
- * Creates a base operation class constructor for generating type-safe operation artifacts.
- *
- * This factory function creates a specialized OperationBase class that implements
- * the provided configuration for identifier generation, export paths, and
- * enrichment handling. The resulting class can be instantiated to generate
- * operation artifacts from OpenAPI operations.
- *
- * @template EnrichmentType - Type of enrichments to apply to generated operations
- * @param config - Configuration defining the operation generation behavior
- * @returns Constructor function for creating operation instances
- *
- * @example Creating a TypeScript function generator
- * ```typescript
- * import { toOperationBase } from '@skmtc/core';
- *
- * const TypeScriptOperationBase = toOperationBase({
- *   id: 'typescript-functions',
- *   toIdentifier: (operation) => new Identifier(camelCase(operation.operationId)),
- *   toExportPath: (operation) => `./operations/${kebabCase(operation.operationId)}.ts`,
- *   toEnrichmentSchema: () => v.object({
- *     includeValidation: v.optional(v.boolean()),
- *     asyncMode: v.optional(v.boolean())
- *   })
- * });
- *
- * class TypeScriptOperationGenerator extends TypeScriptOperationBase {
- *   generate() {
- *     const enrichments = this.enrichments;
- *     const functionCode = generateFunction(this.operation, {
- *       async: enrichments?.asyncMode ?? true
- *     });
- *     this.register({ file: this.createFile(functionCode) });
- *   }
- * }
- * ```
- *
- * @example Creating a React hook generator
- * ```typescript
- * const ReactHookOperationBase = toOperationBase({
- *   id: 'react-hooks',
- *   toIdentifier: (operation) => new Identifier(`use${pascalCase(operation.operationId)}`),
- *   toExportPath: (operation) => `./hooks/${kebabCase(operation.operationId)}.hook.ts`
- * });
- * ```
- */
-export declare const toOperationBase: <EnrichmentType = undefined>(config: BaseOperationConfig<EnrichmentType>) => {
-    new (args: OperationInsertableArgs<EnrichmentType>): {
-        settings: import("../ContentSettings.js").ContentSettings<EnrichmentType>;
-        operation: OasOperation;
-        generatorKey: import("../GeneratorKeys.js").GeneratorKey;
-        insertOperation<V extends import("../GeneratedValue.js").GeneratedValue, EnrichmentType_1 = undefined>(insertable: import("./types.js").OperationInsertable<V, EnrichmentType_1>, operation: OasOperation, options?: Pick<import("../../mod.js").InsertOperationOptions, "noExport">): import("../Inserted.js").Inserted<V, EnrichmentType_1>;
-        insertModel<V extends import("../GeneratedValue.js").GeneratedValue, EnrichmentType_2 = undefined>(insertable: import("../model/types.js").ModelInsertable<V, EnrichmentType_2>, refName: import("../../mod.js").RefName, options?: Pick<import("../../mod.js").InsertModelOptions, "noExport">): import("../Inserted.js").Inserted<V, EnrichmentType_2>;
-        insertNormalizedModel<V extends import("../GeneratedValue.js").GeneratedValue, Schema extends import("../../mod.js").OasSchema | import("../../mod.js").OasRef<"schema"> | import("../../mod.js").OasVoid, EnrichmentType_3 = undefined>(insertable: import("../model/types.js").ModelInsertable<V, EnrichmentType_3>, { schema, fallbackName }: Omit<import("../../mod.js").InsertNormalisedModelArgs<Schema>, "destinationPath">, options?: Pick<import("../../mod.js").InsertModelOptions, "noExport">): import("../../mod.js").InsertNormalisedModelReturn<V, Schema>;
-        defineAndRegister<V extends import("../GeneratedValue.js").GeneratedValue>({ identifier, value, noExport }: Omit<import("../../mod.js").DefineAndRegisterArgs<V>, "destinationPath">): import("../Definition.js").Definition<V>;
-        register(args: import("../../mod.js").BaseRegisterArgs): void;
-        context: GenerateContextType;
-        skipped: boolean;
-    };
-    id: string;
-    type: "operation";
-    toIdentifier: (operation: OasOperation) => Identifier;
-    toExportPath: (operation: OasOperation) => string;
-    toEnrichments: ({ operation, context }: ToEnrichmentsArgs) => EnrichmentType;
-};
-export {};
-//# sourceMappingURL=toOperationBase.d.ts.map

package/esm/dsl/operation/toOperationBase.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toOperationBase.d.ts","sourceRoot":"","sources":["../../../src/dsl/operation/toOperationBase.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAA;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AAEpE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAA;AACzD,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAI5B;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,CAAC,cAAc,GAAG,SAAS,IAAI;IAC5D,oDAAoD;IACpD,EAAE,EAAE,MAAM,CAAA;IACV,uDAAuD;IACvD,YAAY,EAAE,CAAC,SAAS,EAAE,YAAY,KAAK,UAAU,CAAA;IACrD,wDAAwD;IACxD,YAAY,EAAE,CAAC,SAAS,EAAE,YAAY,KAAK,MAAM,CAAA;IACjD,gEAAgE;IAChE,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,UAAU,CAAC,cAAc,EAAE,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAA;CAC9F,CAAA;AAED,KAAK,iBAAiB,GAAG;IACvB,SAAS,EAAE,YAAY,CAAA;IACvB,OAAO,EAAE,mBAAmB,CAAA;CAC7B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,eAAe,GAAI,cAAc,GAAG,SAAS,EACxD,QAAQ,mBAAmB,CAAC,cAAc,CAAC;eAoBvB,uBAAuB,CAAC,cAAc,CAAC;;;;;;;;;;;;;UAhB3C,WAAW;8BA/DD,YAAY,KAAK,UAAU;8BAE3B,YAAY,KAAK,MAAM;oBAkEvB,wBAAwB,iBAAiB,KAAG,cAAc;CAqBrF,CAAA"}

package/esm/dsl/operation/toOperationBase.js

@@ -1,99 +0,0 @@
-import { toOperationGeneratorKey } from '../GeneratorKeys.js';
-import { OperationBase } from './OperationBase.js';
-import * as v from 'valibot';
-import get from 'lodash-es/get.js';
-/**
- * Creates a base operation class constructor for generating type-safe operation artifacts.
- *
- * This factory function creates a specialized OperationBase class that implements
- * the provided configuration for identifier generation, export paths, and
- * enrichment handling. The resulting class can be instantiated to generate
- * operation artifacts from OpenAPI operations.
- *
- * @template EnrichmentType - Type of enrichments to apply to generated operations
- * @param config - Configuration defining the operation generation behavior
- * @returns Constructor function for creating operation instances
- *
- * @example Creating a TypeScript function generator
- * ```typescript
- * import { toOperationBase } from '@skmtc/core';
- *
- * const TypeScriptOperationBase = toOperationBase({
- *   id: 'typescript-functions',
- *   toIdentifier: (operation) => new Identifier(camelCase(operation.operationId)),
- *   toExportPath: (operation) => `./operations/${kebabCase(operation.operationId)}.ts`,
- *   toEnrichmentSchema: () => v.object({
- *     includeValidation: v.optional(v.boolean()),
- *     asyncMode: v.optional(v.boolean())
- *   })
- * });
- *
- * class TypeScriptOperationGenerator extends TypeScriptOperationBase {
- *   generate() {
- *     const enrichments = this.enrichments;
- *     const functionCode = generateFunction(this.operation, {
- *       async: enrichments?.asyncMode ?? true
- *     });
- *     this.register({ file: this.createFile(functionCode) });
- *   }
- * }
- * ```
- *
- * @example Creating a React hook generator
- * ```typescript
- * const ReactHookOperationBase = toOperationBase({
- *   id: 'react-hooks',
- *   toIdentifier: (operation) => new Identifier(`use${pascalCase(operation.operationId)}`),
- *   toExportPath: (operation) => `./hooks/${kebabCase(operation.operationId)}.hook.ts`
- * });
- * ```
- */
-export const toOperationBase = (config) => {
-    var _a;
-    return _a = class extends OperationBase {
-            constructor(args) {
-                super({
-                    ...args,
-                    generatorKey: toOperationGeneratorKey({
-                        generatorId: config.id,
-                        operation: args.operation
-                    })
-                });
-            }
-        },
-        Object.defineProperty(_a, "id", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: config.id
-        }),
-        Object.defineProperty(_a, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 'operation'
-        }),
-        Object.defineProperty(_a, "toIdentifier", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: config.toIdentifier.bind(config)
-        }),
-        Object.defineProperty(_a, "toExportPath", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: config.toExportPath.bind(config)
-        }),
-        Object.defineProperty(_a, "toEnrichments", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ({ operation, context }) => {
-                const operationEnrichments = get(context.settings, `enrichments.${config.id}.${operation.path}.${operation.method}`);
-                const enrichmentSchema = config.toEnrichmentSchema?.() ?? v.optional(v.unknown());
-                return v.parse(enrichmentSchema, operationEnrichments);
-            }
-        }),
-        _a;
-};

package/esm/dsl/operation/toOperationEntry.d.ts

@@ -1,63 +0,0 @@
-import * as v from 'valibot';
-import type { OasOperation } from '../../oas/operation/Operation.js';
-import type { EnrichmentRequest } from '../../types/EnrichmentRequest.js';
-import type { IsSupportedArgs, ToOperationPreviewModuleArgs, ToOperationMappingArgs, TransformOperationArgs } from './types.js';
-import type { IsSupportedOperationConfigArgs } from './types.js';
-import type { MappingModule, PreviewModule } from '../../types/Preview.js';
-/**
- * Configuration arguments for creating operation generator entries.
- *
- * Defines the structure for operation generator configuration including transform functions,
- * enrichment schemas, preview/mapping modules, and support validation.
- *
- * @template EnrichmentType - Type of enrichment data this operation can provide
- * @template Acc - Accumulator type used during operation processing
- */
-export type ToOperationConfigArgs<EnrichmentType = undefined, Acc = void> = {
-    id: string;
-    transform: ({ context, operation, acc }: TransformOperationArgs<Acc>) => Acc;
-    toEnrichmentSchema?: () => v.GenericSchema<EnrichmentType>;
-    isSupported?: ({ context, operation }: IsSupportedOperationConfigArgs<EnrichmentType>) => boolean;
-    toPreviewModule?: ({ context, operation }: ToOperationPreviewModuleArgs) => PreviewModule;
-    toMappingModule?: ({ context, operation }: ToOperationMappingArgs) => MappingModule;
-    toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(operation: OasOperation) => EnrichmentRequest<RequestedEnrichment> | undefined;
-};
-/**
- * Creates a configured operation generator entry.
- *
- * Transforms operation configuration arguments into a standardized operation generator entry
- * that can be used within the SKMTC generation pipeline. Provides type-safe operation processing
- * with optional enrichment support and preview capabilities.
- *
- * @template EnrichmentType - Type of enrichment data this operation provides
- * @template Acc - Accumulator type used during operation processing
- * @param config - Configuration object defining operation behavior
- * @returns Configured operation generator entry ready for pipeline integration
- *
- * @example Basic operation entry
- * ```typescript
- * import { toOperationEntry } from '@skmtc/core';
- *
- * const operationEntry = toOperationEntry({
- *   id: 'my-operation-generator',
- *   transform: ({ context, operation, acc }) => {
- *     // Transform operation into desired format
- *     return processedOperation;
- *   },
- *   isSupported: ({ operation }) => {
- *     return operation.method === 'POST';
- *   }
- * });
- * ```
- */
-export declare const toOperationEntry: <EnrichmentType = undefined, Acc = void>({ id, transform, toEnrichmentSchema, isSupported, toPreviewModule, toMappingModule, toEnrichmentRequest }: ToOperationConfigArgs<EnrichmentType, Acc>) => {
-    id: string;
-    type: "operation";
-    transform: ({ context, operation, acc }: TransformOperationArgs<Acc>) => Acc;
-    toEnrichmentSchema?: () => v.GenericSchema<EnrichmentType>;
-    isSupported: ({ context, operation }: IsSupportedArgs) => boolean;
-    toPreviewModule?: ({ context, operation }: ToOperationPreviewModuleArgs) => PreviewModule;
-    toMappingModule?: ({ context, operation }: ToOperationMappingArgs) => MappingModule;
-    toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(operation: OasOperation) => EnrichmentRequest<RequestedEnrichment> | undefined;
-};
-//# sourceMappingURL=toOperationEntry.d.ts.map

package/esm/dsl/operation/toOperationEntry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"toOperationEntry.d.ts","sourceRoot":"","sources":["../../../src/dsl/operation/toOperationEntry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAA;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAA;AACzE,OAAO,KAAK,EACV,eAAe,EACf,4BAA4B,EAC5B,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAA;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAA;AAG1E;;;;;;;;GAQG;AACH,MAAM,MAAM,qBAAqB,CAAC,cAAc,GAAG,SAAS,EAAE,GAAG,GAAG,IAAI,IAAI;IAC1E,EAAE,EAAE,MAAM,CAAA;IACV,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,sBAAsB,CAAC,GAAG,CAAC,KAAK,GAAG,CAAA;IAC5E,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;IAC1D,WAAW,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,8BAA8B,CAAC,cAAc,CAAC,KAAK,OAAO,CAAA;IACjG,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,4BAA4B,KAAK,aAAa,CAAA;IACzF,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,sBAAsB,KAAK,aAAa,CAAA;IACnF,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,SAAS,cAAc,EAC/D,SAAS,EAAE,YAAY,KACpB,iBAAiB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;CACxD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,gBAAgB,GAAI,cAAc,GAAG,SAAS,EAAE,GAAG,GAAG,IAAI,EAAE,2GAQtE,qBAAqB,CAAC,cAAc,EAAE,GAAG,CAAC,KAAG;IAC9C,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,WAAW,CAAA;IACjB,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,sBAAsB,CAAC,GAAG,CAAC,KAAK,GAAG,CAAA;IAC5E,kBAAkB,CAAC,EAAE,MAAM,CAAC,CAAC,aAAa,CAAC,cAAc,CAAC,CAAA;IAC1D,WAAW,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,eAAe,KAAK,OAAO,CAAA;IACjE,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,4BAA4B,KAAK,aAAa,CAAA;IACzF,eAAe,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,EAAE,sBAAsB,KAAK,aAAa,CAAA;IACnF,mBAAmB,CAAC,EAAE,CAAC,mBAAmB,SAAS,cAAc,EAC/D,SAAS,EAAE,YAAY,KACpB,iBAAiB,CAAC,mBAAmB,CAAC,GAAG,SAAS,CAAA;CA6BxD,CAAA"}

package/esm/dsl/operation/toOperationEntry.js

@@ -1,53 +0,0 @@
-import * as v from 'valibot';
-import get from 'lodash-es/get.js';
-/**
- * Creates a configured operation generator entry.
- *
- * Transforms operation configuration arguments into a standardized operation generator entry
- * that can be used within the SKMTC generation pipeline. Provides type-safe operation processing
- * with optional enrichment support and preview capabilities.
- *
- * @template EnrichmentType - Type of enrichment data this operation provides
- * @template Acc - Accumulator type used during operation processing
- * @param config - Configuration object defining operation behavior
- * @returns Configured operation generator entry ready for pipeline integration
- *
- * @example Basic operation entry
- * ```typescript
- * import { toOperationEntry } from '@skmtc/core';
- *
- * const operationEntry = toOperationEntry({
- *   id: 'my-operation-generator',
- *   transform: ({ context, operation, acc }) => {
- *     // Transform operation into desired format
- *     return processedOperation;
- *   },
- *   isSupported: ({ operation }) => {
- *     return operation.method === 'POST';
- *   }
- * });
- * ```
- */
-export const toOperationEntry = ({ id, transform, toEnrichmentSchema, isSupported, toPreviewModule, toMappingModule, toEnrichmentRequest }) => {
-    return {
-        id,
-        type: 'operation',
-        transform,
-        toEnrichmentSchema,
-        isSupported: ({ context, operation }) => {
-            if (!isSupported) {
-                return true;
-            }
-            const operationEnrichments = get(context.settings, `enrichments.${id}.${operation.path}.${operation.method}`);
-            const enrichmentSchema = toEnrichmentSchema?.() ?? v.undefined();
-            return isSupported({
-                context,
-                operation,
-                enrichments: v.parse(enrichmentSchema, operationEnrichments)
-            });
-        },
-        toPreviewModule,
-        toMappingModule,
-        toEnrichmentRequest
-    };
-};

package/esm/dsl/operation/types.d.ts

@@ -1,125 +0,0 @@
-import type { OasOperation } from '../../oas/operation/Operation.js';
-import type { ContentSettings } from '../ContentSettings.js';
-import type { GenerateContextType } from '../../context/generateTypes.js';
-import type { Identifier } from '../Identifier.js';
-import type { EnrichmentRequest } from '../../types/EnrichmentRequest.js';
-import type * as v from 'valibot';
-import type { MappingModule, PreviewModule } from '../../types/Preview.js';
-/**
- * Arguments passed to operation insertable constructors.
- *
- * @template EnrichmentType - Optional enrichment data type for additional metadata
- */
-export type OperationInsertableArgs<EnrichmentType = undefined> = {
-    context: GenerateContextType;
-    settings: ContentSettings<EnrichmentType>;
-    operation: OasOperation;
-};
-/**
- * Arguments passed to operation transformation functions.
- *
- * @template Acc - Accumulator type for collecting transformation results
- */
-export type TransformOperationArgs<Acc> = {
-    context: GenerateContextType;
-    operation: OasOperation;
-    acc: Acc | undefined;
-};
-/**
- * Interface for objects that provide operation transformation capabilities.
- *
- * Used by generator configurations to transform operation definitions
- * during the code generation process.
- */
-export type WithTransformOperation = {
-    transformOperation: (operation: OasOperation) => void;
-};
-/**
- * Arguments for checking if an operation is supported with enrichment configuration.
- *
- * @template EnrichmentType - Optional enrichment data type for additional metadata
- */
-export type IsSupportedOperationConfigArgs<EnrichmentType = undefined> = {
-    context: GenerateContextType;
-    operation: OasOperation;
-    enrichments: EnrichmentType;
-};
-/**
- * Arguments for checking if an operation is supported for code generation.
- */
-export type IsSupportedOperationArgs = {
-    context: GenerateContextType;
-    operation: OasOperation;
-};
-/**
- * Arguments for generating enrichment data for operations.
- */
-export type ToOperationEnrichmentsArgs = {
-    operation: OasOperation;
-    context: GenerateContextType;
-};
-/**
- * Arguments for generating operation preview modules.
- *
- * Preview modules provide quick insights into generated operations
- * without full code generation.
- */
-export type ToOperationPreviewModuleArgs = {
-    context: GenerateContextType;
-    operation: OasOperation;
-};
-/**
- * Arguments for generating operation mapping information.
- *
- * Mappings track relationships between OAS operations and generated code,
- * enabling cross-references and dependency analysis.
- */
-export type ToOperationMappingArgs = {
-    context: GenerateContextType;
-    operation: OasOperation;
-};
-/**
- * Configuration object for insertable operation generators.
- *
- * Defines the contract for operation generator classes that can be inserted
- * into the generation context to produce type-safe operation definitions.
- *
- * @template V - Generated value type produced by the operation generator
- * @template EnrichmentType - Optional enrichment data type for additional metadata
- */
-export type OperationInsertable<V, EnrichmentType = undefined> = {
-    prototype: V;
-} & {
-    new ({ context, settings, operation }: OperationInsertableArgs<EnrichmentType>): V;
-    id: string;
-    type: 'operation';
-    toIdentifier: (operation: OasOperation) => Identifier;
-    toExportPath: (operation: OasOperation) => string;
-    toEnrichments: ({ operation, context }: ToOperationEnrichmentsArgs) => EnrichmentType;
-} & Function;
-/**
- * Arguments for checking if an operation is supported for generation.
- */
-export type IsSupportedArgs = {
-    context: GenerateContextType;
-    operation: OasOperation;
-};
-/**
- * Configuration object for operation generators.
- *
- * Defines the behavior and capabilities of operation generators including
- * support detection, transformation logic, and enrichment handling.
- *
- * @template EnrichmentType - Optional enrichment data type for additional metadata
- */
-export type OperationConfig<EnrichmentType = undefined> = {
-    id: string;
-    type: 'operation';
-    transform: <Acc = void>({ context, operation, acc }: TransformOperationArgs<Acc>) => Acc;
-    toEnrichmentSchema?: () => v.GenericSchema<EnrichmentType>;
-    isSupported: ({ context, operation }: IsSupportedArgs) => boolean;
-    toPreviewModule?: ({ context, operation }: ToOperationPreviewModuleArgs) => PreviewModule;
-    toMappingModule?: ({ context, operation }: ToOperationMappingArgs) => MappingModule;
-    toEnrichmentRequest?: <RequestedEnrichment extends EnrichmentType>(operation: OasOperation) => EnrichmentRequest<RequestedEnrichment> | undefined;
-};
-//# sourceMappingURL=types.d.ts.map

package/esm/dsl/operation/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/dsl/operation/types.ts"],"names":[],"mappings":"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"}

package/esm/helpers/protectedKeywords.d.ts

@@ -1,2 +0,0 @@
-export declare const protectedKeywords: Record<string, string>;
-//# sourceMappingURL=protectedKeywords.d.ts.map

package/esm/helpers/protectedKeywords.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"protectedKeywords.d.ts","sourceRoot":"","sources":["../../src/helpers/protectedKeywords.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAoEpD,CAAA"}