@wp-typia/project-tools 0.11.1

package/dist/runtime/metadata-projection.js

@@ -0,0 +1,233 @@
+import { cloneJsonValue } from "./json-utils.js";
+import { getWordPressKind, } from "./metadata-model.js";
+export function createBlockJsonAttribute(node, warnings) {
+    const attribute = {
+        type: getWordPressKind(node),
+    };
+    if (node.defaultValue !== undefined) {
+        attribute.default = cloneJsonValue(node.defaultValue);
+    }
+    if (node.enumValues !== null && node.enumValues.length > 0) {
+        attribute.enum = [...node.enumValues];
+    }
+    if (node.wp.source !== null) {
+        attribute.source = node.wp.source;
+    }
+    if (node.wp.selector !== null) {
+        attribute.selector = node.wp.selector;
+    }
+    const reasons = [];
+    if (node.constraints.exclusiveMaximum !== null)
+        reasons.push("exclusiveMaximum");
+    if (node.constraints.exclusiveMinimum !== null)
+        reasons.push("exclusiveMinimum");
+    if (node.constraints.format !== null)
+        reasons.push("format");
+    if (node.constraints.maxLength !== null)
+        reasons.push("maxLength");
+    if (node.constraints.maxItems !== null)
+        reasons.push("maxItems");
+    if (node.constraints.maximum !== null)
+        reasons.push("maximum");
+    if (node.constraints.minLength !== null)
+        reasons.push("minLength");
+    if (node.constraints.minItems !== null)
+        reasons.push("minItems");
+    if (node.constraints.minimum !== null)
+        reasons.push("minimum");
+    if (node.constraints.multipleOf !== null)
+        reasons.push("multipleOf");
+    if (node.constraints.pattern !== null)
+        reasons.push("pattern");
+    if (node.constraints.typeTag !== null)
+        reasons.push("typeTag");
+    if (node.kind === "array" && node.items !== undefined)
+        reasons.push("items");
+    if (node.kind === "object" && node.properties !== undefined)
+        reasons.push("properties");
+    if (node.kind === "union" && node.union !== null)
+        reasons.push("union");
+    if (reasons.length > 0) {
+        warnings.push(`${node.path}: ${reasons.join(", ")}`);
+    }
+    return attribute;
+}
+export function createManifestAttribute(node) {
+    return {
+        typia: {
+            constraints: { ...node.constraints },
+            defaultValue: node.defaultValue === undefined ? null : cloneJsonValue(node.defaultValue),
+            hasDefault: node.defaultValue !== undefined,
+        },
+        ts: {
+            items: node.items ? createManifestAttribute(node.items) : null,
+            kind: node.kind,
+            properties: node.properties
+                ? Object.fromEntries(Object.entries(node.properties).map(([key, property]) => [
+                    key,
+                    createManifestAttribute(property),
+                ]))
+                : null,
+            required: node.required,
+            union: node.union
+                ? {
+                    branches: Object.fromEntries(Object.entries(node.union.branches).map(([key, branch]) => [
+                        key,
+                        createManifestAttribute(branch),
+                    ])),
+                    discriminator: node.union.discriminator,
+                }
+                : null,
+        },
+        wp: {
+            defaultValue: node.defaultValue === undefined ? null : cloneJsonValue(node.defaultValue),
+            enum: node.enumValues ? [...node.enumValues] : null,
+            hasDefault: node.defaultValue !== undefined,
+            ...(node.wp.selector !== null ? { selector: node.wp.selector } : {}),
+            ...(node.wp.source !== null ? { source: node.wp.source } : {}),
+            type: getWordPressKind(node),
+        },
+    };
+}
+export function createManifestDocument(sourceTypeName, attributes) {
+    return {
+        attributes: Object.fromEntries(Object.entries(attributes).map(([key, node]) => [
+            key,
+            createManifestAttribute(node),
+        ])),
+        manifestVersion: 2,
+        sourceType: sourceTypeName,
+    };
+}
+export function validateWordPressExtractionAttributes(attributes) {
+    for (const attribute of Object.values(attributes)) {
+        validateWordPressExtractionAttribute(attribute, true);
+    }
+}
+export function validateWordPressExtractionAttribute(node, isTopLevel = false) {
+    const hasSelector = node.wp.selector !== null;
+    const hasSource = node.wp.source !== null;
+    if (hasSelector || hasSource) {
+        if (!isTopLevel) {
+            throw new Error(`WordPress extraction tags are only supported on top-level block attributes at ${node.path}`);
+        }
+        if (!hasSelector || !hasSource) {
+            throw new Error(`WordPress extraction tags require both Source and Selector at ${node.path}`);
+        }
+        if (node.kind !== "string") {
+            throw new Error(`WordPress extraction tags are only supported on string attributes at ${node.path}`);
+        }
+    }
+    if (node.items !== undefined) {
+        validateWordPressExtractionAttribute(node.items, false);
+    }
+    if (node.properties !== undefined) {
+        for (const property of Object.values(node.properties)) {
+            validateWordPressExtractionAttribute(property, false);
+        }
+    }
+    if (node.union?.branches) {
+        for (const branch of Object.values(node.union.branches)) {
+            validateWordPressExtractionAttribute(branch, false);
+        }
+    }
+}
+export function createExampleValue(node, key) {
+    if (node.defaultValue !== undefined) {
+        return cloneJsonValue(node.defaultValue);
+    }
+    if (node.enumValues !== null && node.enumValues.length > 0) {
+        return cloneJsonValue(node.enumValues[0]);
+    }
+    switch (node.kind) {
+        case "string":
+            return fitStringExampleToConstraints(createFormattedStringExample(node.constraints.format, key), node.constraints);
+        case "number":
+            return createNumericExample(node);
+        case "boolean":
+            return true;
+        case "array":
+            return createArrayExample(node, key);
+        case "object":
+            return Object.fromEntries(Object.entries(node.properties ?? {}).map(([propertyKey, propertyNode]) => [
+                propertyKey,
+                createExampleValue(propertyNode, propertyKey),
+            ]));
+        case "union": {
+            const firstBranch = node.union
+                ? Object.values(node.union.branches)[0]
+                : undefined;
+            if (!firstBranch || firstBranch.kind !== "object") {
+                return {};
+            }
+            return Object.fromEntries(Object.entries(firstBranch.properties ?? {}).map(([propertyKey, propertyNode]) => [
+                propertyKey,
+                createExampleValue(propertyNode, propertyKey),
+            ]));
+        }
+    }
+}
+function createFormattedStringExample(format, key) {
+    switch (format) {
+        case "uuid":
+            return "00000000-0000-4000-8000-000000000000";
+        case "email":
+            return "example@example.com";
+        case "url":
+        case "uri":
+            return "https://example.com";
+        case "ipv4":
+            return "127.0.0.1";
+        case "ipv6":
+            return "::1";
+        case "date-time":
+            return "2024-01-01T00:00:00Z";
+        default:
+            return `Example ${key}`;
+    }
+}
+function fitStringExampleToConstraints(value, constraints) {
+    let nextValue = value;
+    if (constraints.maxLength !== null &&
+        nextValue.length > constraints.maxLength) {
+        nextValue = nextValue.slice(0, constraints.maxLength);
+    }
+    if (constraints.minLength !== null &&
+        nextValue.length < constraints.minLength) {
+        nextValue = nextValue.padEnd(constraints.minLength, "x");
+    }
+    return nextValue;
+}
+function createNumericExample(node) {
+    const { exclusiveMaximum, exclusiveMinimum, maximum, minimum, multipleOf, } = node.constraints;
+    const step = multipleOf && multipleOf !== 0 ? multipleOf : 1;
+    const minCandidate = minimum ?? (exclusiveMinimum !== null ? exclusiveMinimum + step : null);
+    const maxCandidate = maximum ?? (exclusiveMaximum !== null ? exclusiveMaximum - step : null);
+    let candidate = multipleOf && multipleOf !== 0
+        ? minCandidate !== null
+            ? Math.ceil(minCandidate / multipleOf) * multipleOf
+            : maxCandidate !== null
+                ? Math.floor(maxCandidate / multipleOf) * multipleOf
+                : multipleOf
+        : minCandidate ?? maxCandidate ?? 42;
+    if (maxCandidate !== null && candidate > maxCandidate) {
+        candidate =
+            multipleOf && multipleOf !== 0
+                ? Math.floor(maxCandidate / multipleOf) * multipleOf
+                : maxCandidate;
+    }
+    if (minCandidate !== null && candidate < minCandidate) {
+        candidate =
+            multipleOf && multipleOf !== 0
+                ? Math.ceil(minCandidate / multipleOf) * multipleOf
+                : minCandidate;
+    }
+    return candidate;
+}
+function createArrayExample(node, key) {
+    const minimumItems = Math.max(node.constraints.minItems ?? 0, 0);
+    if (minimumItems === 0 || node.items === undefined) {
+        return [];
+    }
+    return Array.from({ length: minimumItems }, (_value, index) => createExampleValue(node.items, `${key}${index + 1}`));
+}

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

@@ -0,0 +1,15 @@
+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:";

package/dist/runtime/migration-constants.js

@@ -0,0 +1,16 @@
+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:";

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

@@ -0,0 +1,2 @@
+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;