@wp-typia/project-tools 0.24.3 → 0.24.5

package/dist/runtime/templates/template-source.js

@@ -0,0 +1,133 @@
+import { OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE, isBuiltInTemplateId, } from './template-registry.js';
+import { resolveBuiltInTemplateSource } from './template-builtins.js';
+import { parseTemplateLocator, } from './template-source-locators.js';
+import { detectTemplateSourceFormat, getTemplateProjectTypeAsync, getDefaultCategoryAsync, getTemplateVariableContext, normalizeCreateBlockSubset, normalizeWpTypiaTemplateSeed, renderCreateBlockExternalTemplate, } from './template-source-normalization.js';
+import { isOfficialWorkspaceTemplateSeedAsync, resolveTemplateSeed, } from './template-source-seeds.js';
+import { assertBuiltInTemplateVariantAllowed, } from '../cli/cli-validation.js';
+import { getScaffoldTemplateVariableGroups } from './scaffold-template-variable-groups.js';
+export { parseGitHubTemplateLocator, parseNpmTemplateLocator, parseTemplateLocator, } from './template-source-locators.js';
+export { resolveTemplateSeed } from './template-source-seeds.js';
+export async function resolveTemplateSource(templateId, cwd, variables, variant) {
+    if (isBuiltInTemplateId(templateId)) {
+        const variableGroups = getScaffoldTemplateVariableGroups(variables);
+        assertBuiltInTemplateVariantAllowed({
+            templateId,
+            variant,
+        });
+        return resolveBuiltInTemplateSource(templateId, {
+            persistenceEnabled: variableGroups.compound.enabled &&
+                variableGroups.compound.persistenceEnabled,
+            persistencePolicy: variableGroups.persistence.enabled &&
+                variableGroups.persistence.policy === 'public'
+                ? 'public'
+                : 'authenticated',
+        });
+    }
+    const locator = parseTemplateLocator(templateId);
+    const context = getTemplateVariableContext(variables);
+    const seed = await resolveTemplateSeed(locator, cwd);
+    const isOfficialWorkspaceTemplate = templateId === OFFICIAL_WORKSPACE_TEMPLATE_PACKAGE ||
+        (await isOfficialWorkspaceTemplateSeedAsync(seed));
+    let normalizedSeed = null;
+    try {
+        const format = await detectTemplateSourceFormat(seed.blockDir);
+        if (format === 'wp-typia') {
+            if (variant) {
+                throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for "${templateId}".`);
+            }
+            normalizedSeed = await normalizeWpTypiaTemplateSeed(seed);
+            const supportsMigrationUi = (await getTemplateProjectTypeAsync(seed.blockDir)) === 'workspace';
+            return {
+                id: templateId,
+                defaultCategory: await getDefaultCategoryAsync(seed.blockDir),
+                description: 'A remote wp-typia template source',
+                features: ['Remote source', 'wp-typia format'],
+                format,
+                isOfficialWorkspaceTemplate,
+                supportsMigrationUi,
+                templateDir: normalizedSeed.blockDir,
+                cleanup: normalizedSeed.cleanup,
+            };
+        }
+        normalizedSeed =
+            format === 'create-block-external'
+                ? await renderCreateBlockExternalTemplate(seed.blockDir, context, variant)
+                : variant
+                    ? (() => {
+                        throw new Error(`--variant is only supported for official external template configs. Received variant "${variant}" for "${templateId}".`);
+                    })()
+                    : seed;
+        if (format === 'create-block-external') {
+            const renderedFormat = normalizedSeed.formatHint ??
+                (await detectTemplateSourceFormat(normalizedSeed.blockDir));
+            if (renderedFormat === 'wp-typia') {
+                const normalized = await normalizeWpTypiaTemplateSeed(normalizedSeed);
+                try {
+                    const [projectType, defaultCategory] = await Promise.all([
+                        getTemplateProjectTypeAsync(normalizedSeed.blockDir),
+                        getDefaultCategoryAsync(normalizedSeed.blockDir),
+                    ]);
+                    const supportsMigrationUi = projectType === 'workspace';
+                    return {
+                        cleanup: async () => {
+                            await normalized.cleanup?.();
+                            await seed.cleanup?.();
+                        },
+                        defaultCategory,
+                        description: 'A wp-typia scaffold normalized from an official external template config',
+                        features: [
+                            'Remote source',
+                            'official external template',
+                            'wp-typia format',
+                            ...(supportsMigrationUi ? ['workspace-capable scaffold'] : []),
+                        ],
+                        format,
+                        id: 'remote:create-block-external',
+                        isOfficialWorkspaceTemplate,
+                        selectedVariant: normalizedSeed.selectedVariant ?? null,
+                        supportsMigrationUi,
+                        templateDir: normalized.blockDir,
+                        warnings: normalizedSeed.warnings ?? [],
+                    };
+                }
+                catch (error) {
+                    await normalized.cleanup?.();
+                    throw error;
+                }
+            }
+            const normalized = await normalizeCreateBlockSubset(normalizedSeed, context);
+            return {
+                ...normalized,
+                cleanup: async () => {
+                    await normalized.cleanup?.();
+                    await seed.cleanup?.();
+                },
+                description: 'A wp-typia scaffold normalized from an official create-block external template',
+                features: [
+                    'Remote source',
+                    'official external template',
+                    'Typia metadata pipeline',
+                ],
+                format,
+                id: 'remote:create-block-external',
+                isOfficialWorkspaceTemplate,
+                selectedVariant: normalizedSeed.selectedVariant ?? null,
+                warnings: normalizedSeed.warnings ?? [],
+            };
+        }
+        const normalized = await normalizeCreateBlockSubset(normalizedSeed, context);
+        return {
+            ...normalized,
+            isOfficialWorkspaceTemplate,
+        };
+    }
+    catch (error) {
+        if (normalizedSeed?.cleanup && normalizedSeed !== seed) {
+            await normalizedSeed.cleanup();
+        }
+        if (seed.cleanup) {
+            await seed.cleanup();
+        }
+        throw error;
+    }
+}

package/dist/runtime/ts-property-names.d.ts

@@ -1,11 +1 @@
-import ts from "typescript";
-/**
- * Extract the literal text for TypeScript property names this runtime supports.
- *
- * Computed property names are intentionally not resolved because their runtime
- * values are not statically knowable from the syntax node alone.
- *
- * @param name TypeScript property name node.
- * @returns Identifier, string-literal, or numeric-literal text; otherwise `null`.
- */
-export declare function getPropertyNameText(name: ts.PropertyName): string | null;
+export * from "./shared/ts-property-names.js";

package/dist/runtime/ts-property-names.js

@@ -1,16 +1 @@
-import ts from "typescript";
-/**
- * Extract the literal text for TypeScript property names this runtime supports.
- *
- * Computed property names are intentionally not resolved because their runtime
- * values are not statically knowable from the syntax node alone.
- *
- * @param name TypeScript property name node.
- * @returns Identifier, string-literal, or numeric-literal text; otherwise `null`.
- */
-export function getPropertyNameText(name) {
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
-        return name.text;
-    }
-    return null;
-}
+export * from "./shared/ts-property-names.js";

package/dist/runtime/ts-source-masking.d.ts

@@ -1,28 +1 @@
-/** Original-source range returned from a masked-source pattern match. */
-export interface SourceRange {
-    end: number;
-    start: number;
-}
-/**
- * Masks TypeScript comments with spaces while preserving newlines and offsets.
- */
-export declare function maskTypeScriptComments(source: string): string;
-/**
- * Masks TypeScript comments and quoted/template literals with spaces while
- * preserving source offsets. This is a lightweight lexer for runtime checks,
- * not a full TypeScript parser, so template interpolation and regex/division
- * ambiguity are intentionally left to callers that need deeper syntax analysis.
- */
-export declare function maskTypeScriptCommentsAndLiterals(source: string): string;
-/**
- * Tests for a pattern after hiding comments and quoted/template literals.
- */
-export declare function hasExecutablePattern(source: string, pattern: RegExp): boolean;
-/**
- * Tests for a pattern after hiding comments while leaving literals intact.
- */
-export declare function hasUncommentedPattern(source: string, pattern: RegExp): boolean;
-/**
- * Finds the first masked-source match that maps back to the original source.
- */
-export declare function findExecutablePatternMatch(source: string, patterns: readonly RegExp[]): SourceRange | undefined;
+export * from "./shared/ts-source-masking.js";

package/dist/runtime/ts-source-masking.js

@@ -1,104 +1 @@
-function maskSourceSegment(segment) {
-    return segment.replace(/[^\n\r]/gu, " ");
-}
-function testPattern(source, pattern) {
-    pattern.lastIndex = 0;
-    const matched = pattern.test(source);
-    pattern.lastIndex = 0;
-    return matched;
-}
-/**
- * Masks TypeScript comments with spaces while preserving newlines and offsets.
- */
-export function maskTypeScriptComments(source) {
-    return source
-        .replace(/\/\*[\s\S]*?\*\//gu, maskSourceSegment)
-        .replace(/\/\/[^\n\r]*/gu, maskSourceSegment);
-}
-/**
- * Masks TypeScript comments and quoted/template literals with spaces while
- * preserving source offsets. This is a lightweight lexer for runtime checks,
- * not a full TypeScript parser, so template interpolation and regex/division
- * ambiguity are intentionally left to callers that need deeper syntax analysis.
- */
-export function maskTypeScriptCommentsAndLiterals(source) {
-    let maskedSource = "";
-    let index = 0;
-    while (index < source.length) {
-        const current = source[index];
-        const next = source[index + 1];
-        if (current === "/" && next === "/") {
-            const start = index;
-            index += 2;
-            while (index < source.length &&
-                source[index] !== "\n" &&
-                source[index] !== "\r") {
-                index += 1;
-            }
-            maskedSource += maskSourceSegment(source.slice(start, index));
-            continue;
-        }
-        if (current === "/" && next === "*") {
-            const start = index;
-            index += 2;
-            while (index < source.length &&
-                !(source[index] === "*" && source[index + 1] === "/")) {
-                index += 1;
-            }
-            index = Math.min(index + 2, source.length);
-            maskedSource += maskSourceSegment(source.slice(start, index));
-            continue;
-        }
-        if (current === "'" || current === '"' || current === "`") {
-            const start = index;
-            const quote = current;
-            index += 1;
-            while (index < source.length) {
-                const char = source[index];
-                if (char === "\\") {
-                    index += 2;
-                    continue;
-                }
-                index += 1;
-                if (char === quote) {
-                    break;
-                }
-            }
-            maskedSource += maskSourceSegment(source.slice(start, index));
-            continue;
-        }
-        maskedSource += current;
-        index += 1;
-    }
-    return maskedSource;
-}
-/**
- * Tests for a pattern after hiding comments and quoted/template literals.
- */
-export function hasExecutablePattern(source, pattern) {
-    return testPattern(maskTypeScriptCommentsAndLiterals(source), pattern);
-}
-/**
- * Tests for a pattern after hiding comments while leaving literals intact.
- */
-export function hasUncommentedPattern(source, pattern) {
-    return testPattern(maskTypeScriptComments(source), pattern);
-}
-/**
- * Finds the first masked-source match that maps back to the original source.
- */
-export function findExecutablePatternMatch(source, patterns) {
-    const maskedSource = maskTypeScriptCommentsAndLiterals(source);
-    for (const pattern of patterns) {
-        pattern.lastIndex = 0;
-        const match = pattern.exec(maskedSource);
-        pattern.lastIndex = 0;
-        if (match && match.index !== undefined) {
-            return {
-                end: match.index + match[0].length,
-                start: match.index,
-            };
-        }
-    }
-    return undefined;
-}
+export * from "./shared/ts-source-masking.js";

package/dist/runtime/typia-llm-json-schema.d.ts

@@ -1,24 +1 @@
-import type { JsonSchemaObject } from './schema-core.js';
-/**
- * Clone a JSON-compatible value when the caller has provided one.
- *
- * @template T JSON-compatible value type.
- * @param value Optional value to clone with the shared JSON clone helper.
- * @returns A cloned value, or undefined when the input is undefined.
- */
-export declare function cloneJsonValueIfDefined<T>(value: T | undefined): T | undefined;
-/**
- * Check whether a candidate is a non-null JSON Schema object.
- *
- * @param value Candidate value to narrow.
- * @returns True when the value is an object and not an array.
- */
-export declare function isJsonSchemaObject(value: unknown): value is JsonSchemaObject;
-/**
- * Narrow a `typia.llm` artifact field before applying JSON Schema mutations.
- *
- * @param value Candidate schema value emitted by `typia.llm`.
- * @param context Human-readable artifact path for diagnostics.
- * @returns The value narrowed to the shared JSON Schema object shape.
- */
-export declare function assertJsonSchemaObject(value: unknown, context: string): JsonSchemaObject;
+export * from "./schema/typia-llm-json-schema.js";

package/dist/runtime/typia-llm-json-schema.js

@@ -1,33 +1 @@
-import { cloneJsonValue } from './json-utils.js';
-/**
- * Clone a JSON-compatible value when the caller has provided one.
- *
- * @template T JSON-compatible value type.
- * @param value Optional value to clone with the shared JSON clone helper.
- * @returns A cloned value, or undefined when the input is undefined.
- */
-export function cloneJsonValueIfDefined(value) {
-    return value === undefined ? undefined : cloneJsonValue(value);
-}
-/**
- * Check whether a candidate is a non-null JSON Schema object.
- *
- * @param value Candidate value to narrow.
- * @returns True when the value is an object and not an array.
- */
-export function isJsonSchemaObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-/**
- * Narrow a `typia.llm` artifact field before applying JSON Schema mutations.
- *
- * @param value Candidate schema value emitted by `typia.llm`.
- * @param context Human-readable artifact path for diagnostics.
- * @returns The value narrowed to the shared JSON Schema object shape.
- */
-export function assertJsonSchemaObject(value, context) {
-    if (isJsonSchemaObject(value)) {
-        return value;
-    }
-    throw new Error(`${context} must be a JSON Schema object.`);
-}
+export * from "./schema/typia-llm-json-schema.js";

package/dist/runtime/typia-llm-openapi-constraints.d.ts

@@ -1,20 +1 @@
-import type { ApplyOpenApiConstraintsToTypiaLlmFunctionArtifactOptions, ProjectedTypiaLlmFunctionArtifact } from './typia-llm-types.js';
-/**
- * Clone a projected function artifact before mutation-oriented constraint work.
- *
- * @param functionArtifact Projected artifact to clone.
- * @returns A cloned artifact with parameters and optional output deep-cloned,
- * and tags shallow-copied when present.
- */
-export declare function cloneProjectedTypiaLlmFunctionArtifact(functionArtifact: ProjectedTypiaLlmFunctionArtifact): ProjectedTypiaLlmFunctionArtifact;
-/**
- * Restores canonical request and response constraints from an endpoint-aware
- * OpenAPI document onto one projected `typia.llm` function artifact.
- *
- * Query-only inputs merge into the root parameter object. Mixed body/query
- * inputs merge into the generated `body` and `query` properties.
- *
- * @param options Projected artifact plus the canonical OpenAPI document.
- * @returns A cloned artifact enriched with OpenAPI-backed constraints when available.
- */
-export declare function applyOpenApiConstraintsToTypiaLlmFunctionArtifact({ functionArtifact, openApiDocument, operationId, }: ApplyOpenApiConstraintsToTypiaLlmFunctionArtifactOptions): ProjectedTypiaLlmFunctionArtifact;
+export * from "./schema/typia-llm-openapi-constraints.js";

package/dist/runtime/typia-llm-openapi-constraints.js

@@ -1,254 +1 @@
-import { cloneJsonValue } from './json-utils.js';
-import { assertJsonSchemaObject, cloneJsonValueIfDefined, isJsonSchemaObject, } from './typia-llm-json-schema.js';
-const JSON_SCHEMA_CONSTRAINT_KEYS = [
-    'additionalProperties',
-    'const',
-    'default',
-    'enum',
-    'exclusiveMaximum',
-    'exclusiveMinimum',
-    'format',
-    'maxItems',
-    'maxLength',
-    'maximum',
-    'minItems',
-    'minLength',
-    'minimum',
-    'multipleOf',
-    'pattern',
-    'type',
-];
-function decodeJsonPointerSegment(segment) {
-    return segment.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-function resolveOpenApiReferenceTarget(document, reference) {
-    if (!reference.startsWith('#/')) {
-        throw new Error(`Unsupported OpenAPI schema reference "${reference}".`);
-    }
-    let current = document;
-    for (const rawSegment of reference.slice(2).split('/')) {
-        const segment = decodeJsonPointerSegment(rawSegment);
-        if (Array.isArray(current)) {
-            const index = Number.parseInt(segment, 10);
-            current = Number.isInteger(index) ? current[index] : undefined;
-            continue;
-        }
-        if (!isJsonSchemaObject(current)) {
-            current = undefined;
-            break;
-        }
-        current = current[segment];
-    }
-    if (!isJsonSchemaObject(current)) {
-        throw new Error(`Unable to resolve OpenAPI schema reference "${reference}".`);
-    }
-    return current;
-}
-function resolveOpenApiSchemaObject(document, schema, seenReferences = new Set()) {
-    if (!isJsonSchemaObject(schema)) {
-        return {};
-    }
-    const reference = schema.$ref;
-    if (typeof reference !== 'string') {
-        return schema;
-    }
-    if (seenReferences.has(reference)) {
-        return schema;
-    }
-    return resolveOpenApiSchemaObject(document, resolveOpenApiReferenceTarget(document, reference), new Set([...seenReferences, reference]));
-}
-function collectOpenApiSeenReferences(schema, seenReferences) {
-    const reference = schema.$ref;
-    if (typeof reference !== 'string' || seenReferences.has(reference)) {
-        return seenReferences;
-    }
-    return new Set([...seenReferences, reference]);
-}
-/**
- * Copy constraint-oriented JSON Schema keywords from `source` into `target`.
- *
- * This helper intentionally mutates and returns `target` so nested OpenAPI
- * constraint restoration can preserve the projected typia.llm schema shape.
- * Callers that need immutable behavior should clone the target before calling.
- */
-function mergeJsonSchemaConstraintProperties(document, target, source, seenReferences = new Set()) {
-    const nextSeenReferences = collectOpenApiSeenReferences(source, seenReferences);
-    const resolvedSource = resolveOpenApiSchemaObject(document, source, seenReferences);
-    const merged = target;
-    for (const key of JSON_SCHEMA_CONSTRAINT_KEYS) {
-        if (resolvedSource[key] !== undefined) {
-            merged[key] = cloneJsonValue(resolvedSource[key]);
-        }
-    }
-    if (Array.isArray(resolvedSource.required)) {
-        merged.required = resolvedSource.required.filter((value) => typeof value === 'string');
-    }
-    if (Array.isArray(resolvedSource.items)) {
-        merged.items = cloneJsonValue(resolvedSource.items);
-    }
-    else if (isJsonSchemaObject(resolvedSource.items)) {
-        const nextItems = isJsonSchemaObject(merged.items) ? merged.items : {};
-        merged.items = mergeJsonSchemaConstraintProperties(document, nextItems, resolvedSource.items, nextSeenReferences);
-    }
-    if (isJsonSchemaObject(resolvedSource.properties)) {
-        const targetProperties = isJsonSchemaObject(merged.properties)
-            ? merged.properties
-            : {};
-        for (const [propertyName, propertySchema] of Object.entries(resolvedSource.properties)) {
-            if (!isJsonSchemaObject(propertySchema)) {
-                continue;
-            }
-            const nextProperty = isJsonSchemaObject(targetProperties[propertyName])
-                ? targetProperties[propertyName]
-                : {};
-            targetProperties[propertyName] = mergeJsonSchemaConstraintProperties(document, nextProperty, propertySchema, nextSeenReferences);
-        }
-        merged.properties = targetProperties;
-    }
-    return merged;
-}
-function findOpenApiOperationById(document, operationId) {
-    for (const pathItem of Object.values(document.paths)) {
-        if (!isJsonSchemaObject(pathItem)) {
-            continue;
-        }
-        for (const method of ['delete', 'get', 'patch', 'post', 'put']) {
-            const operation = resolveOpenApiSchemaObject(document, pathItem[method]);
-            if (!isJsonSchemaObject(operation) ||
-                typeof operation.operationId !== 'string') {
-                continue;
-            }
-            if (operation.operationId === operationId) {
-                return operation;
-            }
-        }
-    }
-    return null;
-}
-function resolveOpenApiRequestBodySchema(operation, document) {
-    const requestBody = resolveOpenApiSchemaObject(document, operation.requestBody);
-    const content = isJsonSchemaObject(requestBody.content)
-        ? requestBody.content
-        : null;
-    const jsonMediaType = content && isJsonSchemaObject(content['application/json'])
-        ? content['application/json']
-        : null;
-    const schema = jsonMediaType?.schema;
-    if (!isJsonSchemaObject(schema)) {
-        return null;
-    }
-    return resolveOpenApiSchemaObject(document, schema);
-}
-function resolveOpenApiSuccessResponseSchema(operation, document) {
-    for (const [statusCode, response] of Object.entries(operation.responses)) {
-        const resolvedResponse = resolveOpenApiSchemaObject(document, response);
-        if (!/^2(?:\d\d|XX)$/u.test(statusCode) ||
-            !isJsonSchemaObject(resolvedResponse)) {
-            continue;
-        }
-        const content = isJsonSchemaObject(resolvedResponse.content)
-            ? resolvedResponse.content
-            : null;
-        const jsonMediaType = content && isJsonSchemaObject(content['application/json'])
-            ? content['application/json']
-            : null;
-        const schema = jsonMediaType?.schema;
-        if (!isJsonSchemaObject(schema)) {
-            continue;
-        }
-        return resolveOpenApiSchemaObject(document, schema);
-    }
-    return null;
-}
-function getOrCreateObjectProperty(target, propertyName) {
-    const targetProperties = isJsonSchemaObject(target.properties)
-        ? target.properties
-        : {};
-    const nextProperty = isJsonSchemaObject(targetProperties[propertyName])
-        ? targetProperties[propertyName]
-        : {};
-    targetProperties[propertyName] = nextProperty;
-    target.properties = targetProperties;
-    return nextProperty;
-}
-function applyOpenApiQueryParameterConstraints(target, operation, document) {
-    for (const parameter of operation.parameters ?? []) {
-        const resolvedParameter = resolveOpenApiSchemaObject(document, parameter);
-        if (!isJsonSchemaObject(resolvedParameter) ||
-            resolvedParameter.in !== 'query' ||
-            typeof resolvedParameter.name !== 'string') {
-            continue;
-        }
-        const propertyTarget = getOrCreateObjectProperty(target, resolvedParameter.name);
-        mergeJsonSchemaConstraintProperties(document, propertyTarget, resolveOpenApiSchemaObject(document, resolvedParameter.schema));
-        if (resolvedParameter.required === true) {
-            const required = new Set(Array.isArray(target.required)
-                ? target.required.filter((value) => typeof value === 'string')
-                : []);
-            required.add(resolvedParameter.name);
-            target.required = [...required];
-        }
-    }
-}
-/**
- * Clone a projected function artifact before mutation-oriented constraint work.
- *
- * @param functionArtifact Projected artifact to clone.
- * @returns A cloned artifact with parameters and optional output deep-cloned,
- * and tags shallow-copied when present.
- */
-export function cloneProjectedTypiaLlmFunctionArtifact(functionArtifact) {
-    return {
-        description: functionArtifact.description,
-        name: functionArtifact.name,
-        output: cloneJsonValueIfDefined(functionArtifact.output),
-        parameters: cloneJsonValue(functionArtifact.parameters),
-        ...(functionArtifact.tags ? { tags: [...functionArtifact.tags] } : {}),
-    };
-}
-/**
- * Restores canonical request and response constraints from an endpoint-aware
- * OpenAPI document onto one projected `typia.llm` function artifact.
- *
- * Query-only inputs merge into the root parameter object. Mixed body/query
- * inputs merge into the generated `body` and `query` properties.
- *
- * @param options Projected artifact plus the canonical OpenAPI document.
- * @returns A cloned artifact enriched with OpenAPI-backed constraints when available.
- */
-export function applyOpenApiConstraintsToTypiaLlmFunctionArtifact({ functionArtifact, openApiDocument, operationId, }) {
-    const constrainedArtifact = cloneProjectedTypiaLlmFunctionArtifact(functionArtifact);
-    const operation = findOpenApiOperationById(openApiDocument, operationId);
-    if (!operation) {
-        return constrainedArtifact;
-    }
-    const hasQueryParameters = (operation.parameters ?? []).some((parameter) => {
-        const resolvedParameter = resolveOpenApiSchemaObject(openApiDocument, parameter);
-        return (isJsonSchemaObject(resolvedParameter) &&
-            resolvedParameter.in === 'query' &&
-            typeof resolvedParameter.name === 'string');
-    });
-    const requestBodySchema = resolveOpenApiRequestBodySchema(operation, openApiDocument);
-    const parameterSchema = assertJsonSchemaObject(constrainedArtifact.parameters, `typia.llm parameters for "${constrainedArtifact.name}"`);
-    if (requestBodySchema) {
-        if (hasQueryParameters) {
-            mergeJsonSchemaConstraintProperties(openApiDocument, getOrCreateObjectProperty(parameterSchema, 'body'), requestBodySchema);
-        }
-        else {
-            mergeJsonSchemaConstraintProperties(openApiDocument, parameterSchema, requestBodySchema);
-        }
-    }
-    if (hasQueryParameters) {
-        applyOpenApiQueryParameterConstraints(requestBodySchema
-            ? getOrCreateObjectProperty(parameterSchema, 'query')
-            : parameterSchema, operation, openApiDocument);
-    }
-    if (constrainedArtifact.output) {
-        const outputSchema = assertJsonSchemaObject(constrainedArtifact.output, `typia.llm output for "${constrainedArtifact.name}"`);
-        const responseSchema = resolveOpenApiSuccessResponseSchema(operation, openApiDocument);
-        if (responseSchema) {
-            mergeJsonSchemaConstraintProperties(openApiDocument, outputSchema, responseSchema);
-        }
-    }
-    return constrainedArtifact;
-}
+export * from "./schema/typia-llm-openapi-constraints.js";

package/dist/runtime/typia-llm-projection.d.ts

@@ -1,25 +1 @@
-import type { ProjectedTypiaLlmApplicationArtifact, ProjectedTypiaLlmFunctionArtifact, ProjectedTypiaLlmStructuredOutputArtifact, ProjectTypiaLlmApplicationArtifactOptions, ProjectTypiaLlmStructuredOutputArtifactOptions, TypiaLlmFunctionLike } from './typia-llm-types.js';
-/**
- * Projects one compiled `typia.llm` function schema into a JSON-friendly
- * artifact record.
- *
- * @param functionSchema Function schema from a compiled `typia.llm.application(...)`.
- * @returns JSON-friendly function artifact.
- */
-export declare function projectTypiaLlmApplicationFunction(functionSchema: TypiaLlmFunctionLike): ProjectedTypiaLlmFunctionArtifact;
-/**
- * Projects a compiled `typia.llm.application(...)` result into a JSON-friendly
- * downstream adapter artifact.
- *
- * @param options Compiled application value and source metadata.
- * @returns JSON-friendly application artifact.
- */
-export declare function projectTypiaLlmApplicationArtifact({ application, generatedFrom, openApiProjection, transformFunction, }: ProjectTypiaLlmApplicationArtifactOptions): ProjectedTypiaLlmApplicationArtifact;
-/**
- * Projects a compiled `typia.llm.structuredOutput(...)` result into a
- * JSON-friendly downstream adapter artifact.
- *
- * @param options Compiled structured-output value and source metadata.
- * @returns JSON-friendly structured-output artifact.
- */
-export declare function projectTypiaLlmStructuredOutputArtifact({ generatedFrom, structuredOutput, }: ProjectTypiaLlmStructuredOutputArtifactOptions): ProjectedTypiaLlmStructuredOutputArtifact;
+export * from "./schema/typia-llm-projection.js";