@wp-typia/project-tools 0.24.4 → 0.24.5

package/dist/runtime/migration-constants.d.ts

@@ -1,15 +1 @@
-export declare const ROOT_BLOCK_JSON = "block.json";
-export declare const ROOT_MANIFEST = "typia.manifest.json";
-export declare const ROOT_PHP_MIGRATION_REGISTRY = "typia-migration-registry.php";
-export declare const SRC_BLOCK_JSON: string;
-export declare const SRC_MANIFEST: string;
-export declare const ROOT_SAVE_FILE: string;
-export declare const ROOT_TYPES_FILE: string;
-export declare const MIGRATIONS_DIR: string;
-export declare const CONFIG_FILE: string;
-export declare const GENERATED_DIR: string;
-export declare const FIXTURES_DIR: string;
-export declare const RULES_DIR: string;
-export declare const SNAPSHOT_DIR: string;
-export declare const SUPPORTED_PROJECT_FILES: string[];
-export declare const MIGRATION_TODO_PREFIX = "TODO MIGRATION:";
+export * from "./migration/migration-constants.js";

package/dist/runtime/migration-constants.js

@@ -1,16 +1 @@
-import path from "node:path";
-export const ROOT_BLOCK_JSON = "block.json";
-export const ROOT_MANIFEST = "typia.manifest.json";
-export const ROOT_PHP_MIGRATION_REGISTRY = "typia-migration-registry.php";
-export const SRC_BLOCK_JSON = path.join("src", "block.json");
-export const SRC_MANIFEST = path.join("src", "typia.manifest.json");
-export const ROOT_SAVE_FILE = path.join("src", "save.tsx");
-export const ROOT_TYPES_FILE = path.join("src", "types.ts");
-export const MIGRATIONS_DIR = path.join("src", "migrations");
-export const CONFIG_FILE = path.join(MIGRATIONS_DIR, "config.ts");
-export const GENERATED_DIR = path.join(MIGRATIONS_DIR, "generated");
-export const FIXTURES_DIR = path.join(MIGRATIONS_DIR, "fixtures");
-export const RULES_DIR = path.join(MIGRATIONS_DIR, "rules");
-export const SNAPSHOT_DIR = path.join(MIGRATIONS_DIR, "versions");
-export const SUPPORTED_PROJECT_FILES = ["package.json", ROOT_BLOCK_JSON, ROOT_SAVE_FILE, ROOT_TYPES_FILE];
-export const MIGRATION_TODO_PREFIX = "TODO MIGRATION:";
+export * from "./migration/migration-constants.js";

package/dist/runtime/migration-diff-rename.d.ts

@@ -1,13 +1 @@
-import type { FlattenedAttributeDescriptor, ManifestAttribute, RenameCandidate } from "./migration-types.js";
-interface CreateRenameCandidatesOptions {
-    addedKeys: string[];
-    isUnionRenameCompatible: (oldAttribute: ManifestAttribute, newAttribute: ManifestAttribute) => boolean;
-    newAttributes: Record<string, ManifestAttribute>;
-    newLeafAttributes: FlattenedAttributeDescriptor[];
-    oldAttributes: Record<string, ManifestAttribute>;
-    oldLeafAttributes: FlattenedAttributeDescriptor[];
-    removedKeys: string[];
-}
-export declare function createRenameCandidates({ addedKeys, isUnionRenameCompatible, newAttributes, newLeafAttributes, oldAttributes, oldLeafAttributes, removedKeys, }: CreateRenameCandidatesOptions): RenameCandidate[];
-export declare function passesNameSimilarityRule(legacyPath: string, currentPath: string): boolean;
-export {};
+export * from "./migration/migration-diff-rename.js";

package/dist/runtime/migration-diff-rename.js

@@ -1,192 +1 @@
-export function createRenameCandidates({ addedKeys, isUnionRenameCompatible, newAttributes, newLeafAttributes, oldAttributes, oldLeafAttributes, removedKeys, }) {
-    const assessments = [];
-    for (const currentPath of addedKeys) {
-        const nextAttribute = newAttributes[currentPath];
-        if (!nextAttribute)
-            continue;
-        for (const legacyPath of removedKeys) {
-            const previous = oldAttributes[legacyPath];
-            if (!previous)
-                continue;
-            const candidate = assessRenameCandidate(previous, nextAttribute, legacyPath, currentPath, isUnionRenameCompatible);
-            if (candidate) {
-                assessments.push(candidate);
-            }
-        }
-    }
-    const oldLeafMap = new Map(oldLeafAttributes.map((descriptor) => [descriptor.currentPath, descriptor]));
-    const newLeafMap = new Map(newLeafAttributes.map((descriptor) => [descriptor.currentPath, descriptor]));
-    const removedLeafDescriptors = oldLeafAttributes.filter((descriptor) => !newLeafMap.has(descriptor.currentPath));
-    const addedLeafDescriptors = newLeafAttributes.filter((descriptor) => !oldLeafMap.has(descriptor.currentPath));
-    for (const nextDescriptor of addedLeafDescriptors) {
-        if (!nextDescriptor.currentPath.includes(".")) {
-            continue;
-        }
-        for (const previousDescriptor of removedLeafDescriptors) {
-            if (!previousDescriptor.currentPath.includes(".")) {
-                continue;
-            }
-            const candidate = assessRenameCandidate(previousDescriptor.attribute, nextDescriptor.attribute, previousDescriptor.currentPath, nextDescriptor.currentPath, isUnionRenameCompatible);
-            if (candidate) {
-                assessments.push(candidate);
-            }
-        }
-    }
-    return assessments
-        .map((candidate) => {
-        const currentMatches = assessments
-            .filter((item) => item.currentPath === candidate.currentPath)
-            .sort((left, right) => right.score - left.score);
-        const legacyMatches = assessments
-            .filter((item) => item.legacyPath === candidate.legacyPath)
-            .sort((left, right) => right.score - left.score);
-        const currentLeader = currentMatches[0];
-        const legacyLeader = legacyMatches[0];
-        const currentHasTie = currentMatches.length > 1 && Math.abs((currentMatches[1]?.score ?? 0) - currentLeader.score) < 0.05;
-        const legacyHasTie = legacyMatches.length > 1 && Math.abs((legacyMatches[1]?.score ?? 0) - legacyLeader.score) < 0.05;
-        return {
-            ...candidate,
-            autoApply: currentLeader.legacyPath === candidate.legacyPath &&
-                legacyLeader.currentPath === candidate.currentPath &&
-                !currentHasTie &&
-                !legacyHasTie &&
-                candidate.score >= 0.6,
-        };
-    })
-        .filter((candidate, index, list) => {
-        const firstMatch = list.findIndex((item) => item.currentPath === candidate.currentPath && item.legacyPath === candidate.legacyPath);
-        return firstMatch === index;
-    })
-        .sort((left, right) => right.score - left.score);
-}
-export function passesNameSimilarityRule(legacyPath, currentPath) {
-    return scoreRenameSimilarity(legacyPath, currentPath) >= 0.6;
-}
-function isRenameCandidateShapeCompatible(oldAttribute, newAttribute, isUnionRenameCompatible) {
-    if (!oldAttribute || !newAttribute || oldAttribute.ts.kind !== newAttribute.ts.kind) {
-        return false;
-    }
-    if (["string", "number", "boolean"].includes(oldAttribute.ts.kind)) {
-        return hasRenameCompatibleConstraints(oldAttribute, newAttribute);
-    }
-    if (oldAttribute.ts.kind === "union") {
-        return isUnionRenameCompatible(oldAttribute, newAttribute);
-    }
-    return false;
-}
-function assessRenameCandidate(oldAttribute, newAttribute, legacyPath, currentPath, isUnionRenameCompatible) {
-    if (!isRenameCandidateShapeCompatible(oldAttribute, newAttribute, isUnionRenameCompatible)) {
-        return null;
-    }
-    const baseScore = scoreRenameSimilarity(legacyPath, currentPath);
-    const score = getParentPath(legacyPath) === getParentPath(currentPath) ? Math.max(baseScore, 0.75) : baseScore;
-    return {
-        autoApply: false,
-        currentPath,
-        legacyPath,
-        reason: describeRenameReason(oldAttribute, legacyPath, currentPath, score),
-        score,
-    };
-}
-function hasRenameCompatibleConstraints(oldAttribute, newAttribute) {
-    const oldEnum = oldAttribute.wp.enum ?? null;
-    const nextEnum = newAttribute.wp.enum ?? null;
-    if (oldEnum && nextEnum) {
-        const oldIsSubset = oldEnum.every((value) => nextEnum.includes(value));
-        if (!oldIsSubset) {
-            return false;
-        }
-    }
-    else if (oldEnum && !nextEnum) {
-        return false;
-    }
-    const oldConstraints = oldAttribute.typia.constraints ?? {};
-    const nextConstraints = newAttribute.typia.constraints ?? {};
-    return [
-        compareMinimumBound(oldConstraints.minLength, nextConstraints.minLength),
-        compareMaximumBound(oldConstraints.maxLength, nextConstraints.maxLength),
-        compareMinimumBound(oldConstraints.minimum, nextConstraints.minimum),
-        compareMaximumBound(oldConstraints.maximum, nextConstraints.maximum),
-        comparePatternBound(oldConstraints.pattern, nextConstraints.pattern),
-        comparePatternBound(oldConstraints.format, nextConstraints.format),
-        comparePatternBound(oldConstraints.typeTag, nextConstraints.typeTag),
-    ].every(Boolean);
-}
-function compareMinimumBound(oldValue, nextValue) {
-    if (nextValue === null || nextValue === undefined)
-        return true;
-    if (oldValue === null || oldValue === undefined)
-        return true;
-    return Number(oldValue) <= Number(nextValue);
-}
-function compareMaximumBound(oldValue, nextValue) {
-    if (nextValue === null || nextValue === undefined)
-        return true;
-    if (oldValue === null || oldValue === undefined)
-        return true;
-    return Number(oldValue) >= Number(nextValue);
-}
-function comparePatternBound(oldValue, nextValue) {
-    return oldValue === nextValue || oldValue === null || oldValue === undefined;
-}
-function scoreRenameSimilarity(legacyPath, currentPath) {
-    const legacy = normalizeFieldName(legacyPath);
-    const current = normalizeFieldName(currentPath);
-    if (legacy === current)
-        return 1;
-    if (shareAliasGroup(legacy, current))
-        return 0.9;
-    const legacyTokens = tokenizeFieldName(legacy);
-    const currentTokens = tokenizeFieldName(current);
-    const overlap = legacyTokens.filter((token) => currentTokens.includes(token));
-    const jaccard = overlap.length / new Set([...legacyTokens, ...currentTokens]).size;
-    if (legacy.includes(current) || current.includes(legacy)) {
-        return Math.max(jaccard, 0.7);
-    }
-    if (legacyTokens.length > 0 &&
-        currentTokens.length > 0 &&
-        legacyTokens[legacyTokens.length - 1] === currentTokens[currentTokens.length - 1]) {
-        return Math.max(jaccard, 0.6);
-    }
-    return jaccard;
-}
-function normalizeFieldName(name) {
-    return String(name)
-        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-        .replace(/[^a-zA-Z0-9]+/g, " ")
-        .trim()
-        .toLowerCase()
-        .replace(/\s+/g, "");
-}
-function tokenizeFieldName(name) {
-    return String(name)
-        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-        .toLowerCase()
-        .split(/[^a-z0-9]+/)
-        .filter(Boolean);
-}
-function getParentPath(pathLabel) {
-    const segments = String(pathLabel).split(".");
-    return segments.length <= 1 ? "" : segments.slice(0, -1).join(".");
-}
-function shareAliasGroup(left, right) {
-    const aliasGroups = [
-        ["content", "headline", "body", "text", "copy", "message"],
-        ["id", "uniqueid", "uuid"],
-        ["visible", "isvisible", "show", "shown", "enabled"],
-        ["align", "alignment", "textalign"],
-        ["count", "clickcount", "counter"],
-        ["url", "href", "link"],
-    ];
-    return aliasGroups.some((group) => group.includes(left) && group.includes(right));
-}
-function describeRenameReason(attribute, legacyPath, currentPath, score) {
-    if (attribute.ts.kind === "union") {
-        return `compatible discriminated union (${legacyPath} → ${currentPath})`;
-    }
-    if (score >= 0.9)
-        return "high-confidence compatible field";
-    if (score >= 0.6)
-        return "name-similar compatible field";
-    return "compatible field requiring review";
-}
+export * from "./migration/migration-diff-rename.js";

package/dist/runtime/migration-diff-transform.d.ts

@@ -1,14 +1 @@
-import type { DiffOutcome, FlattenedAttributeDescriptor, ManifestAttribute, RenameCandidate, TransformSuggestion } from "./migration-types.js";
-interface CreateTransformSuggestionsOptions {
-    addedKeys: string[];
-    manualItems: DiffOutcome[];
-    newAttributes: Record<string, ManifestAttribute>;
-    newLeafAttributes: FlattenedAttributeDescriptor[];
-    oldAttributes: Record<string, ManifestAttribute>;
-    oldLeafAttributes: FlattenedAttributeDescriptor[];
-    removedKeys: string[];
-    renameCandidates: RenameCandidate[];
-}
-export declare function createTransformSuggestions({ oldAttributes, newAttributes, addedKeys, removedKeys, manualItems, renameCandidates, oldLeafAttributes, newLeafAttributes, }: CreateTransformSuggestionsOptions): TransformSuggestion[];
-export declare function describeConstraintChange(oldAttribute: ManifestAttribute, newAttribute: ManifestAttribute): string;
-export {};
+export * from "./migration/migration-diff-transform.js";

package/dist/runtime/migration-diff-transform.js

@@ -1,105 +1 @@
-import { getAttributeByCurrentPath } from "./migration-manifest.js";
-import { passesNameSimilarityRule } from "./migration-diff-rename.js";
-export function createTransformSuggestions({ oldAttributes, newAttributes, addedKeys, removedKeys, manualItems, renameCandidates, oldLeafAttributes, newLeafAttributes, }) {
-    const suggestions = [];
-    const activeRenameTargets = new Set(renameCandidates.filter((candidate) => candidate.autoApply).map((candidate) => candidate.currentPath));
-    const oldLeafMap = new Map(oldLeafAttributes.map((descriptor) => [descriptor.currentPath, descriptor]));
-    const newLeafMap = new Map(newLeafAttributes.map((descriptor) => [descriptor.currentPath, descriptor]));
-    for (const currentPath of [
-        ...new Set([
-            ...Object.keys(newAttributes),
-            ...manualItems.map((item) => item.path),
-            ...newLeafAttributes.map((item) => item.currentPath),
-        ]),
-    ]) {
-        if (activeRenameTargets.has(currentPath)) {
-            continue;
-        }
-        const manualItem = manualItems.find((item) => item.path === currentPath || item.path.startsWith(`${currentPath}.`));
-        const currentAttribute = newLeafMap.get(currentPath)?.attribute ??
-            getAttributeByCurrentPath(newAttributes, currentPath) ??
-            null;
-        if (!manualItem || !currentAttribute) {
-            continue;
-        }
-        const exactLegacy = oldLeafMap.get(currentPath)?.attribute ??
-            getAttributeByCurrentPath(oldAttributes, currentPath) ??
-            null;
-        if (exactLegacy && exactLegacy.ts.kind !== currentAttribute.ts.kind) {
-            suggestions.push({
-                bodyLines: buildTransformBodyLines(currentAttribute, currentPath),
-                attribute: currentAttribute,
-                currentPath,
-                legacyPath: currentPath,
-                reason: `semantic coercion suggested for ${manualItem.kind}`,
-            });
-            continue;
-        }
-        const bestRenameCandidate = renameCandidates.find((candidate) => candidate.currentPath === currentPath);
-        if (bestRenameCandidate && !bestRenameCandidate.autoApply) {
-            suggestions.push({
-                bodyLines: buildTransformBodyLines(currentAttribute, bestRenameCandidate.legacyPath),
-                attribute: currentAttribute,
-                currentPath,
-                legacyPath: bestRenameCandidate.legacyPath,
-                reason: `review coercion from ${bestRenameCandidate.legacyPath}`,
-            });
-            continue;
-        }
-        const addedCurrent = addedKeys.includes(currentPath) ||
-            (newLeafMap.has(currentPath) && !oldLeafMap.has(currentPath));
-        if (!addedCurrent) {
-            continue;
-        }
-        const compatibleLegacyPath = [
-            ...removedKeys,
-            ...oldLeafAttributes
-                .filter((descriptor) => !newLeafMap.has(descriptor.currentPath))
-                .map((descriptor) => descriptor.currentPath),
-        ].find((legacyPath) => passesNameSimilarityRule(legacyPath, currentPath));
-        if (compatibleLegacyPath) {
-            suggestions.push({
-                bodyLines: buildTransformBodyLines(currentAttribute, compatibleLegacyPath),
-                attribute: currentAttribute,
-                currentPath,
-                legacyPath: compatibleLegacyPath,
-                reason: `review coercion from ${compatibleLegacyPath}`,
-            });
-        }
-    }
-    return suggestions;
-}
-export function describeConstraintChange(oldAttribute, newAttribute) {
-    const details = [];
-    const oldConstraints = oldAttribute.typia.constraints;
-    const nextConstraints = newAttribute.typia.constraints;
-    if (newAttribute.wp.enum && JSON.stringify(newAttribute.wp.enum) !== JSON.stringify(oldAttribute.wp.enum)) {
-        details.push("enum changed");
-    }
-    for (const key of ["minLength", "maxLength", "minimum", "maximum", "pattern", "format", "typeTag"]) {
-        if (oldConstraints[key] !== nextConstraints[key]) {
-            details.push(`${key}: ${oldConstraints[key]} -> ${nextConstraints[key]}`);
-        }
-    }
-    return details.join(", ");
-}
-function buildTransformBodyLines(attribute, legacyPath) {
-    switch (attribute.ts.kind) {
-        case "string":
-            return [`// return typeof legacyValue === "string" ? legacyValue : String(legacyValue ?? "");`];
-        case "number":
-            return [
-                `// const numericValue = typeof legacyValue === "number" ? legacyValue : Number(legacyValue ?? 0);`,
-                `// return Number.isNaN(numericValue) ? undefined : numericValue;`,
-            ];
-        case "boolean":
-            return [`// return typeof legacyValue === "boolean" ? legacyValue : Boolean(legacyValue);`];
-        case "union":
-            return [
-                `// const legacyObject = typeof legacyValue === "object" && legacyValue !== null ? legacyValue : {};`,
-                `// return legacyObject; // adjust discriminator / branch fields before verify`,
-            ];
-        default:
-            return [`// return legacyValue; // customize migration from ${legacyPath}`];
-    }
-}
+export * from "./migration/migration-diff-transform.js";

package/dist/runtime/migration-diff.d.ts

@@ -1,2 +1 @@
-import type { MigrationBlockConfig, MigrationDiff, MigrationProjectState, ResolvedMigrationBlockTarget } from "./migration-types.js";
-export declare function createMigrationDiff(state: MigrationProjectState, blockOrFromVersion: MigrationBlockConfig | ResolvedMigrationBlockTarget | string, fromVersionOrToVersion: string, maybeToVersion?: string): MigrationDiff;
+export * from "./migration/migration-diff.js";

package/dist/runtime/migration-diff.js

@@ -1,252 +1 @@
-import fs from "node:fs";
-import { flattenManifestLeafAttributes, getManifestDefaultValue, hasManifestDefault, } from "./migration-manifest.js";
-import { createRenameCandidates } from "./migration-diff-rename.js";
-import { createTransformSuggestions, describeConstraintChange, } from "./migration-diff-transform.js";
-import { createMissingBlockSnapshotMessage, getAvailableSnapshotVersionsForBlock, getSnapshotManifestPath, } from "./migration-project.js";
-import { isNumber, readJson } from "./migration-utils.js";
-export function createMigrationDiff(state, blockOrFromVersion, fromVersionOrToVersion, maybeToVersion) {
-    if (typeof blockOrFromVersion === "string" && state.blocks.length > 1) {
-        throw new Error("A block key is required when diffing a multi-block migration project.");
-    }
-    const block = typeof blockOrFromVersion === "string"
-        ? state.blocks[0]
-        : state.blocks.find((entry) => entry.key === blockOrFromVersion.key) ?? null;
-    const fromVersion = typeof blockOrFromVersion === "string"
-        ? blockOrFromVersion
-        : fromVersionOrToVersion;
-    const toVersion = typeof blockOrFromVersion === "string"
-        ? fromVersionOrToVersion
-        : maybeToVersion ?? state.config.currentMigrationVersion;
-    if (!block) {
-        throw new Error(typeof blockOrFromVersion === "string"
-            ? "No migration block targets are configured for this project."
-            : `Unknown migration block key: ${blockOrFromVersion.key}`);
-    }
-    const snapshotManifestPath = getSnapshotManifestPath(state.projectDir, block, fromVersion);
-    if (!fs.existsSync(snapshotManifestPath)) {
-        throw new Error(createMissingBlockSnapshotMessage(block.blockName, fromVersion, getAvailableSnapshotVersionsForBlock(state.projectDir, state.config.supportedMigrationVersions, block)));
-    }
-    const targetManifest = toVersion === state.config.currentMigrationVersion
-        ? block.currentManifest
-        : readJson(getSnapshotManifestPath(state.projectDir, block, toVersion));
-    const oldManifest = readJson(snapshotManifestPath);
-    const oldAttributes = oldManifest.attributes ?? {};
-    const newAttributes = targetManifest.attributes ?? {};
-    const oldLeafAttributes = flattenManifestLeafAttributes(oldAttributes);
-    const newLeafAttributes = flattenManifestLeafAttributes(newAttributes);
-    const autoItems = [];
-    const manualItems = [];
-    const addedKeys = [];
-    const removedKeys = [];
-    for (const [key, newAttribute] of Object.entries(newAttributes)) {
-        const oldAttribute = oldAttributes[key];
-        if (!oldAttribute) {
-            addedKeys.push(key);
-            if (newAttribute.ts.required && !hasManifestDefault(newAttribute)) {
-                manualItems.push({
-                    detail: "required field has no default in current schema",
-                    kind: "required-addition",
-                    path: key,
-                    status: "manual",
-                });
-            }
-            else {
-                autoItems.push({
-                    detail: hasManifestDefault(newAttribute)
-                        ? `default ${JSON.stringify(getManifestDefaultValue(newAttribute))}`
-                        : "optional addition",
-                    kind: hasManifestDefault(newAttribute) ? "add-default" : "add-optional",
-                    path: key,
-                    status: "auto",
-                });
-            }
-            continue;
-        }
-        const outcome = compareManifestAttribute(oldAttribute, newAttribute, key);
-        if (outcome.status === "manual") {
-            manualItems.push(outcome);
-        }
-        else {
-            autoItems.push(outcome);
-        }
-    }
-    for (const key of Object.keys(oldAttributes)) {
-        if (!(key in newAttributes)) {
-            removedKeys.push(key);
-            autoItems.push({
-                detail: "field removed from current schema",
-                kind: "drop",
-                path: key,
-                status: "auto",
-            });
-        }
-    }
-    const renameCandidates = createRenameCandidates({
-        addedKeys,
-        isUnionRenameCompatible: (oldAttribute, newAttribute) => compareUnionAttribute(oldAttribute, newAttribute, "$rename").status === "auto",
-        newAttributes,
-        newLeafAttributes,
-        oldAttributes,
-        oldLeafAttributes,
-        removedKeys,
-    });
-    const activeRenameCandidates = renameCandidates.filter((candidate) => candidate.autoApply);
-    for (const candidate of activeRenameCandidates) {
-        removeOutcomeByPath(autoItems, candidate.legacyPath, "drop");
-        removeOutcomeByPath(autoItems, candidate.currentPath, "add-default");
-        removeOutcomeByPath(autoItems, candidate.currentPath, "add-optional");
-        removeOutcomeByPath(manualItems, candidate.currentPath, "required-addition");
-        removeOutcomesByPath(manualItems, candidate.currentPath);
-        autoItems.push({
-            detail: `legacy field ${candidate.legacyPath}`,
-            kind: "rename",
-            path: candidate.currentPath,
-            status: "auto",
-        });
-    }
-    const transformSuggestions = createTransformSuggestions({
-        addedKeys,
-        manualItems,
-        newAttributes,
-        newLeafAttributes,
-        oldAttributes,
-        oldLeafAttributes,
-        renameCandidates,
-        removedKeys,
-    });
-    return {
-        currentTypeName: targetManifest.sourceType ?? block.currentManifest.sourceType,
-        fromVersion,
-        summary: {
-            auto: autoItems.length,
-            autoItems,
-            manual: manualItems.length,
-            manualItems,
-            renameCandidates,
-            transformSuggestions,
-        },
-        toVersion,
-    };
-}
-function removeOutcomeByPath(items, pathLabel, kind) {
-    const index = items.findIndex((item) => item.path === pathLabel && item.kind === kind);
-    if (index >= 0) {
-        items.splice(index, 1);
-    }
-}
-function removeOutcomesByPath(items, pathLabel) {
-    for (let index = items.length - 1; index >= 0; index -= 1) {
-        if (items[index]?.path === pathLabel) {
-            items.splice(index, 1);
-        }
-    }
-}
-function compareManifestAttribute(oldAttribute, newAttribute, attributePath) {
-    if (oldAttribute.ts.kind !== newAttribute.ts.kind) {
-        return manualOutcome(attributePath, "type-change", `${oldAttribute.ts.kind} -> ${newAttribute.ts.kind}`);
-    }
-    if (oldAttribute.ts.kind === "union") {
-        return compareUnionAttribute(oldAttribute, newAttribute, attributePath);
-    }
-    if (oldAttribute.ts.kind === "object") {
-        return compareObjectAttribute(oldAttribute, newAttribute, attributePath);
-    }
-    if (oldAttribute.ts.kind === "array") {
-        if (!oldAttribute.ts.items || !newAttribute.ts.items) {
-            return autoOutcome(attributePath, "copy", "array shape unchanged");
-        }
-        const nested = compareManifestAttribute(oldAttribute.ts.items, newAttribute.ts.items, `${attributePath}[]`);
-        return nested.status === "manual"
-            ? nested
-            : autoOutcome(attributePath, "hydrate", "array items can be normalized");
-    }
-    if (hasStricterConstraints(oldAttribute, newAttribute)) {
-        return manualOutcome(attributePath, "stricter-constraints", describeConstraintChange(oldAttribute, newAttribute));
-    }
-    return autoOutcome(attributePath, "copy", "compatible primitive field");
-}
-function compareObjectAttribute(oldAttribute, newAttribute, attributePath) {
-    const oldProperties = oldAttribute.ts.properties ?? {};
-    const newProperties = newAttribute.ts.properties ?? {};
-    for (const [key, nextProperty] of Object.entries(newProperties)) {
-        const previousProperty = oldProperties[key];
-        if (!previousProperty) {
-            if (nextProperty.ts.required && !hasManifestDefault(nextProperty)) {
-                return manualOutcome(`${attributePath}.${key}`, "object-change", "required field has no default in current schema");
-            }
-            continue;
-        }
-        const nested = compareManifestAttribute(previousProperty, nextProperty, `${attributePath}.${key}`);
-        if (nested.status === "manual") {
-            return nested;
-        }
-    }
-    return autoOutcome(attributePath, "hydrate", "object can be normalized with current manifest defaults");
-}
-function compareUnionAttribute(oldAttribute, newAttribute, attributePath) {
-    const oldUnion = oldAttribute.ts.union;
-    const newUnion = newAttribute.ts.union;
-    if (!oldUnion || !newUnion) {
-        return manualOutcome(attributePath, "union-change", "missing union metadata");
-    }
-    if (oldUnion.discriminator !== newUnion.discriminator) {
-        return manualOutcome(attributePath, "union-discriminator-change", `${oldUnion.discriminator} -> ${newUnion.discriminator}`);
-    }
-    const oldBranchKeys = Object.keys(oldUnion.branches);
-    const newBranchKeys = Object.keys(newUnion.branches);
-    for (const branchKey of oldBranchKeys) {
-        if (!(branchKey in newUnion.branches)) {
-            return manualOutcome(attributePath, "union-branch-removal", `branch ${branchKey} was removed`);
-        }
-        const nested = compareManifestAttribute(oldUnion.branches[branchKey], newUnion.branches[branchKey], `${attributePath}.${branchKey}`);
-        if (nested.status === "manual") {
-            return manualOutcome(nested.path, nested.kind.startsWith("union-") ? nested.kind : "union-manual", nested.detail ?? `branch ${branchKey} requires manual review`);
-        }
-    }
-    const addedBranches = newBranchKeys.filter((branchKey) => !(branchKey in oldUnion.branches));
-    if (addedBranches.length > 0) {
-        return autoOutcome(attributePath, "union-branch-addition", `branches added: ${addedBranches.join(", ")}`);
-    }
-    return autoOutcome(attributePath, "copy", "compatible discriminated union");
-}
-function hasStricterConstraints(oldAttribute, newAttribute) {
-    const oldConstraints = oldAttribute.typia.constraints;
-    const nextConstraints = newAttribute.typia.constraints;
-    const oldEnum = oldAttribute.wp.enum ?? null;
-    const nextEnum = newAttribute.wp.enum ?? null;
-    if (nextEnum && (!oldEnum || !oldEnum.every((value) => nextEnum.includes(value)))) {
-        return true;
-    }
-    if (isNumber(nextConstraints.minLength) &&
-        (!isNumber(oldConstraints.minLength) || nextConstraints.minLength > oldConstraints.minLength)) {
-        return true;
-    }
-    if (isNumber(nextConstraints.maxLength) &&
-        (!isNumber(oldConstraints.maxLength) || nextConstraints.maxLength < oldConstraints.maxLength)) {
-        return true;
-    }
-    if (isNumber(nextConstraints.minimum) &&
-        (!isNumber(oldConstraints.minimum) || nextConstraints.minimum > oldConstraints.minimum)) {
-        return true;
-    }
-    if (isNumber(nextConstraints.maximum) &&
-        (!isNumber(oldConstraints.maximum) || nextConstraints.maximum < oldConstraints.maximum)) {
-        return true;
-    }
-    if (nextConstraints.pattern && nextConstraints.pattern !== oldConstraints.pattern) {
-        return true;
-    }
-    if (nextConstraints.format && nextConstraints.format !== oldConstraints.format) {
-        return true;
-    }
-    if (nextConstraints.typeTag && nextConstraints.typeTag !== oldConstraints.typeTag) {
-        return true;
-    }
-    return false;
-}
-function autoOutcome(pathLabel, kind, detail) {
-    return { detail, kind, path: pathLabel, status: "auto" };
-}
-function manualOutcome(pathLabel, kind, detail) {
-    return { detail, kind, path: pathLabel, status: "manual" };
-}
+export * from "./migration/migration-diff.js";

package/dist/runtime/migration-fixtures.d.ts

@@ -1,8 +1 @@
-import type { MigrationBlockConfig, MigrationDiff, MigrationFixtureDocument } from "./migration-types.js";
-export declare function ensureEdgeFixtureFile(projectDir: string, block: MigrationBlockConfig, fromVersion: string, toVersion: string, diff: MigrationDiff, { force }?: {
-    force?: boolean;
-}): {
-    fixturePath: string;
-    written: boolean;
-};
-export declare function createEdgeFixtureDocument(projectDir: string, block: MigrationBlockConfig, fromVersion: string, toVersion: string, diff: MigrationDiff): MigrationFixtureDocument;
+export * from "./migration/migration-fixtures.js";