@wp-typia/project-tools 0.11.1

package/dist/runtime/starter-manifests.js

@@ -0,0 +1,383 @@
+const ALIGNMENT_VALUES = ["left", "center", "right", "justify"];
+const INTERACTIVE_MODE_VALUES = ["click", "hover", "auto"];
+const ANIMATION_VALUES = ["none", "bounce", "pulse", "shake", "flip"];
+const DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER = "Add supporting details for this internal item.";
+function createConstraints(overrides = {}) {
+    return {
+        exclusiveMaximum: null,
+        exclusiveMinimum: null,
+        format: null,
+        maxLength: null,
+        maxItems: null,
+        maximum: null,
+        minLength: null,
+        minItems: null,
+        minimum: null,
+        multipleOf: null,
+        pattern: null,
+        typeTag: null,
+        ...overrides,
+    };
+}
+function createAttribute({ constraints, defaultValue, enumValues = null, kind, required, sourceType, }) {
+    const hasDefault = defaultValue !== undefined;
+    return {
+        ts: {
+            items: null,
+            kind,
+            properties: null,
+            required,
+            union: null,
+        },
+        typia: {
+            constraints: createConstraints(constraints),
+            defaultValue: hasDefault ? defaultValue : null,
+            hasDefault,
+        },
+        wp: {
+            defaultValue: hasDefault ? defaultValue : null,
+            enum: enumValues,
+            hasDefault,
+            type: sourceType,
+        },
+    };
+}
+function createManifest(sourceType, attributes) {
+    return {
+        attributes,
+        manifestVersion: 2,
+        sourceType,
+    };
+}
+function buildBasicStarterManifest(variables) {
+    return createManifest(`${variables.pascalCase}Attributes`, {
+        alignment: createAttribute({
+            defaultValue: "left",
+            enumValues: [...ALIGNMENT_VALUES],
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        }),
+        className: createAttribute({
+            constraints: {
+                maxLength: 100,
+            },
+            defaultValue: "",
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        }),
+        content: createAttribute({
+            constraints: {
+                maxLength: 1000,
+            },
+            defaultValue: "",
+            kind: "string",
+            required: true,
+            sourceType: "string",
+        }),
+        id: createAttribute({
+            constraints: {
+                format: "uuid",
+            },
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        }),
+        isVisible: createAttribute({
+            defaultValue: true,
+            kind: "boolean",
+            required: false,
+            sourceType: "boolean",
+        }),
+        schemaVersion: createAttribute({
+            constraints: {
+                typeTag: "uint32",
+            },
+            defaultValue: 1,
+            kind: "number",
+            required: false,
+            sourceType: "number",
+        }),
+    });
+}
+function buildInteractivityStarterManifest(variables) {
+    return createManifest(`${variables.pascalCase}Attributes`, {
+        alignment: createAttribute({
+            defaultValue: "left",
+            enumValues: [...ALIGNMENT_VALUES],
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        }),
+        animation: createAttribute({
+            defaultValue: "none",
+            enumValues: [...ANIMATION_VALUES],
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        }),
+        autoPlayInterval: createAttribute({
+            constraints: {
+                minimum: 0,
+                typeTag: "uint32",
+            },
+            defaultValue: 0,
+            kind: "number",
+            required: false,
+            sourceType: "number",
+        }),
+        clickCount: createAttribute({
+            constraints: {
+                minimum: 0,
+                typeTag: "uint32",
+            },
+            defaultValue: 0,
+            kind: "number",
+            required: false,
+            sourceType: "number",
+        }),
+        content: createAttribute({
+            constraints: {
+                maxLength: 1000,
+            },
+            defaultValue: "",
+            kind: "string",
+            required: true,
+            sourceType: "string",
+        }),
+        interactiveMode: createAttribute({
+            defaultValue: "click",
+            enumValues: [...INTERACTIVE_MODE_VALUES],
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        }),
+        isAnimating: createAttribute({
+            defaultValue: false,
+            kind: "boolean",
+            required: false,
+            sourceType: "boolean",
+        }),
+        isVisible: createAttribute({
+            defaultValue: true,
+            kind: "boolean",
+            required: false,
+            sourceType: "boolean",
+        }),
+        maxClicks: createAttribute({
+            constraints: {
+                minimum: 0,
+                typeTag: "uint32",
+            },
+            defaultValue: 10,
+            kind: "number",
+            required: false,
+            sourceType: "number",
+        }),
+        showCounter: createAttribute({
+            defaultValue: true,
+            kind: "boolean",
+            required: false,
+            sourceType: "boolean",
+        }),
+        uniqueId: createAttribute({
+            defaultValue: "",
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        }),
+    });
+}
+function buildPersistenceStarterManifest(variables) {
+    return createManifest(`${variables.pascalCase}Attributes`, {
+        alignment: createAttribute({
+            defaultValue: "left",
+            enumValues: [...ALIGNMENT_VALUES],
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        }),
+        buttonLabel: createAttribute({
+            constraints: {
+                maxLength: 40,
+                minLength: 1,
+            },
+            defaultValue: "Persist Count",
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        }),
+        content: createAttribute({
+            constraints: {
+                maxLength: 250,
+                minLength: 1,
+            },
+            defaultValue: `${variables.title} persistence block`,
+            kind: "string",
+            required: true,
+            sourceType: "string",
+        }),
+        isVisible: createAttribute({
+            defaultValue: true,
+            kind: "boolean",
+            required: false,
+            sourceType: "boolean",
+        }),
+        resourceKey: createAttribute({
+            constraints: {
+                maxLength: 100,
+                minLength: 1,
+            },
+            defaultValue: "primary",
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        }),
+        showCount: createAttribute({
+            defaultValue: true,
+            kind: "boolean",
+            required: false,
+            sourceType: "boolean",
+        }),
+    });
+}
+function buildCompoundParentStarterManifest(variables) {
+    const attributes = {
+        heading: createAttribute({
+            constraints: {
+                maxLength: 80,
+                minLength: 1,
+            },
+            defaultValue: variables.title,
+            kind: "string",
+            required: true,
+            sourceType: "string",
+        }),
+        intro: createAttribute({
+            constraints: {
+                maxLength: 180,
+                minLength: 1,
+            },
+            defaultValue: "Add and reorder internal items inside this compound block.",
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        }),
+        showDividers: createAttribute({
+            defaultValue: true,
+            kind: "boolean",
+            required: false,
+            sourceType: "boolean",
+        }),
+    };
+    if (variables.compoundPersistenceEnabled === "true") {
+        attributes.showCount = createAttribute({
+            defaultValue: true,
+            kind: "boolean",
+            required: false,
+            sourceType: "boolean",
+        });
+        attributes.buttonLabel = createAttribute({
+            constraints: {
+                maxLength: 40,
+                minLength: 1,
+            },
+            defaultValue: "Persist Count",
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        });
+        attributes.resourceKey = createAttribute({
+            constraints: {
+                maxLength: 100,
+                minLength: 1,
+            },
+            defaultValue: "primary",
+            kind: "string",
+            required: false,
+            sourceType: "string",
+        });
+    }
+    return createManifest(`${variables.pascalCase}Attributes`, attributes);
+}
+function buildCompoundChildStarterManifest(variables) {
+    return buildCompoundChildStarterManifestDocument(`${variables.pascalCase}ItemAttributes`, variables.compoundChildTitle);
+}
+/**
+ * Builds the starter manifest used by generated compound child blocks.
+ */
+export function buildCompoundChildStarterManifestDocument(childTypeName, childTitle, bodyPlaceholder = DEFAULT_COMPOUND_CHILD_BODY_PLACEHOLDER) {
+    return createManifest(childTypeName, {
+        body: createAttribute({
+            constraints: {
+                maxLength: 280,
+                minLength: 1,
+            },
+            defaultValue: bodyPlaceholder,
+            kind: "string",
+            required: true,
+            sourceType: "string",
+        }),
+        title: createAttribute({
+            constraints: {
+                maxLength: 80,
+                minLength: 1,
+            },
+            defaultValue: childTitle,
+            kind: "string",
+            required: true,
+            sourceType: "string",
+        }),
+    });
+}
+/**
+ * Returns the starter manifest files that should be seeded for a built-in
+ * template before the first sync.
+ */
+export function getStarterManifestFiles(templateId, variables) {
+    if (templateId === "basic") {
+        return [
+            {
+                document: buildBasicStarterManifest(variables),
+                relativePath: "src/typia.manifest.json",
+            },
+        ];
+    }
+    if (templateId === "interactivity") {
+        return [
+            {
+                document: buildInteractivityStarterManifest(variables),
+                relativePath: "src/typia.manifest.json",
+            },
+        ];
+    }
+    if (templateId === "persistence") {
+        return [
+            {
+                document: buildPersistenceStarterManifest(variables),
+                relativePath: "src/typia.manifest.json",
+            },
+        ];
+    }
+    if (templateId === "compound") {
+        return [
+            {
+                document: buildCompoundParentStarterManifest(variables),
+                relativePath: `src/blocks/${variables.slugKebabCase}/typia.manifest.json`,
+            },
+            {
+                document: buildCompoundChildStarterManifest(variables),
+                relativePath: `src/blocks/${variables.slugKebabCase}-item/typia.manifest.json`,
+            },
+        ];
+    }
+    return [];
+}
+/**
+ * Serializes a starter manifest using the generated-project JSON formatting
+ * convention.
+ */
+export function stringifyStarterManifest(document) {
+    return `${JSON.stringify(document, null, "\t")}\n`;
+}

package/dist/runtime/string-case.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Normalize arbitrary text into a kebab-case identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A lowercase kebab-case string with collapsed separators.
+ */
+export declare function toKebabCase(input: string): string;
+/**
+ * Normalize arbitrary text into a snake_case identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A lowercase snake_case string derived from the kebab-case form.
+ */
+export declare function toSnakeCase(input: string): string;
+/**
+ * Normalize arbitrary text into a PascalCase identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A PascalCase string derived from the normalized kebab-case form.
+ */
+export declare function toPascalCase(input: string): string;
+/**
+ * Convert delimited text to PascalCase while preserving each segment's
+ * existing internal casing.
+ *
+ * @param input Raw text split on non-alphanumeric boundaries.
+ * @returns A PascalCase string that preserves acronyms inside segments.
+ */
+export declare function toSegmentPascalCase(input: string): string;
+/**
+ * Normalize arbitrary text into a human-readable title.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A title-cased string derived from the normalized kebab-case form.
+ */
+export declare function toTitleCase(input: string): string;

package/dist/runtime/string-case.js

@@ -0,0 +1,69 @@
+function capitalizeSegment(segment) {
+    return segment.charAt(0).toUpperCase() + segment.slice(1);
+}
+/**
+ * Normalize arbitrary text into a kebab-case identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A lowercase kebab-case string with collapsed separators.
+ */
+export function toKebabCase(input) {
+    return input
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replace(/[^A-Za-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-")
+        .toLowerCase();
+}
+/**
+ * Normalize arbitrary text into a snake_case identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A lowercase snake_case string derived from the kebab-case form.
+ */
+export function toSnakeCase(input) {
+    return toKebabCase(input).replace(/-/g, "_");
+}
+/**
+ * Normalize arbitrary text into a PascalCase identifier.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A PascalCase string derived from the normalized kebab-case form.
+ */
+export function toPascalCase(input) {
+    return toKebabCase(input)
+        .split("-")
+        .filter(Boolean)
+        .map(capitalizeSegment)
+        .join("");
+}
+/**
+ * Convert delimited text to PascalCase while preserving each segment's
+ * existing internal casing.
+ *
+ * @param input Raw text split on non-alphanumeric boundaries.
+ * @returns A PascalCase string that preserves acronyms inside segments.
+ */
+export function toSegmentPascalCase(input) {
+    return input
+        .replace(/[^A-Za-z0-9]+/g, " ")
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map(capitalizeSegment)
+        .join("");
+}
+/**
+ * Normalize arbitrary text into a human-readable title.
+ *
+ * @param input Raw text that may contain spaces, punctuation, or camelCase.
+ * @returns A title-cased string derived from the normalized kebab-case form.
+ */
+export function toTitleCase(input) {
+    return toKebabCase(input)
+        .split("-")
+        .filter(Boolean)
+        .map(capitalizeSegment)
+        .join(" ");
+}

package/dist/runtime/template-builtins.d.ts

@@ -0,0 +1,38 @@
+import { type BuiltInTemplateId } from "./template-registry.js";
+/**
+ * Controls which persistence layer is applied when materializing the built-in
+ * `persistence` template.
+ */
+export type BuiltInPersistencePolicy = "authenticated" | "public";
+export interface BuiltInTemplateVariantOptions {
+    persistenceEnabled?: boolean;
+    persistencePolicy?: BuiltInPersistencePolicy;
+}
+export interface MaterializedBuiltInTemplateSource {
+    id: BuiltInTemplateId;
+    defaultCategory: string;
+    description: string;
+    features: string[];
+    format: "wp-typia";
+    templateDir: string;
+    cleanup?: () => Promise<void>;
+    selectedVariant?: string | null;
+    warnings?: string[];
+}
+/**
+ * Returns the ordered overlay directories for a built-in template.
+ *
+ * Persistence templates include the shared base, the persistence core layer,
+ * the selected policy layer, and the thin template overlay. All other built-ins
+ * resolve to the shared base plus their own template directory.
+ */
+export declare function getBuiltInTemplateLayerDirs(templateId: BuiltInTemplateId, { persistenceEnabled, persistencePolicy, }?: BuiltInTemplateVariantOptions): string[];
+/**
+ * Materializes a built-in template into a temporary directory by copying each
+ * resolved layer in order.
+ *
+ * Callers should invoke the returned `cleanup` function when they no longer
+ * need the materialized directory. If copying fails, the temporary directory is
+ * removed before the error is rethrown.
+ */
+export declare function resolveBuiltInTemplateSource(templateId: BuiltInTemplateId, options?: BuiltInTemplateVariantOptions): Promise<MaterializedBuiltInTemplateSource>;

package/dist/runtime/template-builtins.js

@@ -0,0 +1,72 @@
+import os from "node:os";
+import path from "node:path";
+import { promises as fsp } from "node:fs";
+import { getTemplateById, SHARED_BASE_TEMPLATE_ROOT, SHARED_COMPOUND_TEMPLATE_ROOT, SHARED_PERSISTENCE_TEMPLATE_ROOT, SHARED_REST_HELPER_TEMPLATE_ROOT, } from "./template-registry.js";
+/**
+ * Returns the ordered overlay directories for a built-in template.
+ *
+ * Persistence templates include the shared base, the persistence core layer,
+ * the selected policy layer, and the thin template overlay. All other built-ins
+ * resolve to the shared base plus their own template directory.
+ */
+export function getBuiltInTemplateLayerDirs(templateId, { persistenceEnabled = false, persistencePolicy = "authenticated", } = {}) {
+    if (templateId === "persistence") {
+        return [
+            SHARED_BASE_TEMPLATE_ROOT,
+            path.join(SHARED_REST_HELPER_TEMPLATE_ROOT, "shared"),
+            path.join(SHARED_PERSISTENCE_TEMPLATE_ROOT, "core"),
+            path.join(SHARED_REST_HELPER_TEMPLATE_ROOT, persistencePolicy === "public" ? "public" : "auth"),
+            path.join(SHARED_PERSISTENCE_TEMPLATE_ROOT, persistencePolicy === "public" ? "public" : "auth"),
+            getTemplateById(templateId).templateDir,
+        ];
+    }
+    if (templateId === "compound") {
+        const layers = [
+            SHARED_BASE_TEMPLATE_ROOT,
+            path.join(SHARED_COMPOUND_TEMPLATE_ROOT, "core"),
+            getTemplateById(templateId).templateDir,
+        ];
+        if (persistenceEnabled) {
+            layers.push(path.join(SHARED_REST_HELPER_TEMPLATE_ROOT, "shared"), path.join(SHARED_COMPOUND_TEMPLATE_ROOT, "persistence"), path.join(SHARED_REST_HELPER_TEMPLATE_ROOT, persistencePolicy === "public" ? "public" : "auth"), path.join(SHARED_COMPOUND_TEMPLATE_ROOT, persistencePolicy === "public" ? "persistence-public" : "persistence-auth"));
+        }
+        return layers;
+    }
+    return [SHARED_BASE_TEMPLATE_ROOT, getTemplateById(templateId).templateDir];
+}
+/**
+ * Materializes a built-in template into a temporary directory by copying each
+ * resolved layer in order.
+ *
+ * Callers should invoke the returned `cleanup` function when they no longer
+ * need the materialized directory. If copying fails, the temporary directory is
+ * removed before the error is rethrown.
+ */
+export async function resolveBuiltInTemplateSource(templateId, options = {}) {
+    const template = getTemplateById(templateId);
+    const tempRoot = await fsp.mkdtemp(path.join(os.tmpdir(), "wp-typia-template-"));
+    const templateDir = path.join(tempRoot, templateId);
+    try {
+        await fsp.mkdir(templateDir, { recursive: true });
+        for (const layerDir of getBuiltInTemplateLayerDirs(templateId, options)) {
+            await fsp.cp(layerDir, templateDir, {
+                recursive: true,
+                force: true,
+            });
+        }
+    }
+    catch (error) {
+        await fsp.rm(tempRoot, { force: true, recursive: true });
+        throw error;
+    }
+    return {
+        id: template.id,
+        defaultCategory: template.defaultCategory,
+        description: template.description,
+        features: template.features,
+        format: "wp-typia",
+        templateDir,
+        cleanup: async () => {
+            await fsp.rm(tempRoot, { force: true, recursive: true });
+        },
+    };
+}

package/dist/runtime/template-defaults.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Internal built-in template metadata defaults used by scaffold rendering.
+ */
+export declare const BUILTIN_BLOCK_METADATA_VERSION = "0.1.0";
+/**
+ * Built-in parent block metadata defaults keyed by template id.
+ */
+export declare const BUILTIN_TEMPLATE_METADATA_DEFAULTS: Readonly<{
+    basic: Readonly<{
+        category: "text";
+        icon: "smiley";
+    }>;
+    interactivity: Readonly<{
+        category: "widgets";
+        icon: "smiley";
+    }>;
+    persistence: Readonly<{
+        category: "widgets";
+        icon: "database";
+    }>;
+    compound: Readonly<{
+        category: "widgets";
+        icon: "screenoptions";
+    }>;
+}>;
+/**
+ * Shared hidden child block metadata defaults for compound scaffolds.
+ */
+export declare const COMPOUND_CHILD_BLOCK_METADATA_DEFAULTS: Readonly<{
+    category: "widgets";
+    icon: "excerpt-view";
+}>;
+/**
+ * Legacy built-in template ids that were removed in favor of persistence modes.
+ */
+export declare const REMOVED_BUILTIN_TEMPLATE_IDS: readonly ["data", "persisted"];
+/**
+ * Union of removed built-in template ids accepted by compatibility checks.
+ */
+export type RemovedBuiltInTemplateId = (typeof REMOVED_BUILTIN_TEMPLATE_IDS)[number];
+/**
+ * Returns the metadata defaults for a built-in scaffold template id.
+ *
+ * @param templateId Built-in template id whose metadata defaults should be read.
+ * @returns The stable category/icon defaults used by scaffold rendering.
+ */
+export declare function getBuiltInTemplateMetadataDefaults(templateId: keyof typeof BUILTIN_TEMPLATE_METADATA_DEFAULTS): Readonly<{
+    category: "text";
+    icon: "smiley";
+}> | Readonly<{
+    category: "widgets";
+    icon: "smiley";
+}> | Readonly<{
+    category: "widgets";
+    icon: "database";
+}> | Readonly<{
+    category: "widgets";
+    icon: "screenoptions";
+}>;
+/**
+ * Checks whether a template id points at a removed built-in scaffold.
+ *
+ * @param templateId Template id supplied to scaffold resolution.
+ * @returns True when the template id is one of the removed legacy built-ins.
+ */
+export declare function isRemovedBuiltInTemplateId(templateId: string): templateId is RemovedBuiltInTemplateId;
+/**
+ * Builds the stable recovery guidance shown for removed built-in template ids.
+ *
+ * @param templateId Removed template id, where `data` maps to the public policy and
+ * `persisted` maps to the authenticated policy.
+ * @returns A user-facing error string in the form
+ * `Built-in template "<id>" was removed. Use --template persistence --persistence-policy <policy> instead.`
+ */
+export declare function getRemovedBuiltInTemplateMessage(templateId: RemovedBuiltInTemplateId): string;