@wp-typia/block-runtime 0.2.3 → 0.4.0

package/dist/identifiers.js

@@ -0,0 +1,84 @@
+const UUID_HEX_RADIX = 16;
+const SCOPED_SUFFIX_LENGTH = 9;
+/**
+ * Generate a UUID v4-style id for block attributes.
+ */
+export function generateBlockId() {
+    return generateUuidV4();
+}
+/**
+ * Generate a prefixed runtime id for client-side attributes such as uniqueId.
+ * @param prefix Prefix chosen by the scaffold/template.
+ */
+export function generateScopedClientId(prefix) {
+    return generatePrefixedScopedId(prefix);
+}
+/**
+ * Generate a prefixed persistence resource key.
+ * @param prefix Prefix chosen by the scaffold/template.
+ */
+export function generateResourceKey(prefix) {
+    return generatePrefixedScopedId(prefix);
+}
+/**
+ * Generate an opaque id for one public write attempt.
+ */
+export function generatePublicWriteRequestId() {
+    return generateUuidV4();
+}
+function generateUuidV4() {
+    const cryptoObject = getCryptoObject();
+    if (typeof cryptoObject?.randomUUID === 'function') {
+        return cryptoObject.randomUUID();
+    }
+    const bytes = fillRandomBytes(16);
+    if (bytes) {
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        return formatUuidBytes(bytes);
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (character) => {
+        const randomNibble = Math.floor(Math.random() * UUID_HEX_RADIX);
+        const value = character === 'x'
+            ? randomNibble
+            : (randomNibble & 0x03) | 0x08;
+        return value.toString(UUID_HEX_RADIX);
+    });
+}
+function generatePrefixedScopedId(prefix) {
+    return `${prefix}-${generateScopedSuffix()}`;
+}
+function generateScopedSuffix() {
+    const bytes = fillRandomBytes(SCOPED_SUFFIX_LENGTH);
+    if (bytes) {
+        return Array.from(bytes, (byte) => (byte % 36).toString(36)).join('');
+    }
+    return Math.random()
+        .toString(36)
+        .slice(2, 2 + SCOPED_SUFFIX_LENGTH)
+        .padEnd(SCOPED_SUFFIX_LENGTH, '0');
+}
+function formatUuidBytes(bytes) {
+    const hex = Array.from(bytes, (byte) => byte.toString(UUID_HEX_RADIX).padStart(2, '0')).join('');
+    return [
+        hex.slice(0, 8),
+        hex.slice(8, 12),
+        hex.slice(12, 16),
+        hex.slice(16, 20),
+        hex.slice(20),
+    ].join('-');
+}
+function fillRandomBytes(size) {
+    const cryptoObject = getCryptoObject();
+    if (typeof cryptoObject?.getRandomValues !== 'function') {
+        return null;
+    }
+    const bytes = new Uint8Array(size);
+    cryptoObject.getRandomValues(bytes);
+    return bytes;
+}
+function getCryptoObject() {
+    return typeof globalThis.crypto === 'object' && globalThis.crypto
+        ? globalThis.crypto
+        : undefined;
+}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./blocks.js";
 export * from "./defaults.js";
 export * from "./editor.js";
 export * from "./validation.js";

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from "./blocks.js";
 export * from "./defaults.js";
 export * from "./editor.js";
 export * from "./validation.js";

package/dist/inspector-runtime.d.ts

@@ -0,0 +1,129 @@
+import React, { type ReactNode } from "react";
+import { type EditorFieldDescriptor, type EditorModelOptions, type ManifestDocument } from "./editor.js";
+import { type ValidationResult } from "./validation.js";
+export type { EditorFieldDescriptor, EditorFieldOption, EditorModelOptions, ManifestAttribute, ManifestDocument, } from "./editor.js";
+export type { ValidationResult } from "./validation.js";
+type UnknownRecord = Record<string, unknown>;
+export interface InspectorSelectOption {
+    label: string;
+    value: string;
+}
+export interface PanelBodyLikeProps {
+    children?: ReactNode;
+    initialOpen?: boolean;
+    title?: ReactNode;
+}
+export interface ToggleControlLikeProps {
+    checked?: boolean;
+    help?: ReactNode;
+    label?: ReactNode;
+    onChange?: (value: boolean) => void;
+}
+export interface SelectControlLikeProps {
+    help?: ReactNode;
+    label?: ReactNode;
+    onChange?: (value: string) => void;
+    options?: readonly InspectorSelectOption[];
+    value?: string;
+}
+export interface RangeControlLikeProps {
+    help?: ReactNode;
+    label?: ReactNode;
+    max?: number;
+    min?: number;
+    onChange?: (value?: number) => void;
+    step?: number;
+    value?: number;
+}
+export interface TextControlLikeProps {
+    help?: ReactNode;
+    label?: ReactNode;
+    max?: number;
+    min?: number;
+    onBlur?: () => void;
+    onChange?: (value: string) => void;
+    step?: number;
+    type?: string;
+    value?: string;
+}
+export interface TextareaControlLikeProps {
+    help?: ReactNode;
+    label?: ReactNode;
+    onChange?: (value: string) => void;
+    value?: string;
+}
+export interface InspectorComponentMap {
+    PanelBody?: React.ElementType<PanelBodyLikeProps>;
+    RangeControl?: React.ElementType<RangeControlLikeProps>;
+    SelectControl?: React.ElementType<SelectControlLikeProps>;
+    TextControl?: React.ElementType<TextControlLikeProps>;
+    TextareaControl?: React.ElementType<TextareaControlLikeProps>;
+    ToggleControl?: React.ElementType<ToggleControlLikeProps>;
+}
+export interface UseEditorFieldsResult {
+    fields: EditorFieldDescriptor[];
+    fieldMap: Map<string, EditorFieldDescriptor>;
+    getBooleanValue: (source: UnknownRecord, path: string, fallback: boolean) => boolean;
+    getField: (path: string) => EditorFieldDescriptor | undefined;
+    getNumberValue: (source: UnknownRecord, path: string, fallback: number) => number;
+    getSelectOptions: (path: string, labelMap?: Record<string, string>) => InspectorSelectOption[];
+    getStringValue: (source: UnknownRecord, path: string, fallback: string) => string;
+    manualFields: EditorFieldDescriptor[];
+    supportedFields: EditorFieldDescriptor[];
+}
+export interface TypedAttributeUpdater<T extends object> {
+    updateAttribute: <K extends keyof T>(key: K, value: T[K]) => boolean;
+    updateField: <K extends keyof T>(path: K | string, value: unknown) => boolean;
+    updatePath: (path: string, value: unknown) => boolean;
+}
+export interface FieldControlRenderContext {
+    components: InspectorComponentMap;
+    field: EditorFieldDescriptor;
+    help?: ReactNode;
+    label?: ReactNode;
+    max?: number;
+    min?: number;
+    onChange: (value: unknown) => void;
+    options?: readonly InspectorSelectOption[];
+    step?: number;
+    value: unknown;
+}
+export interface FieldControlProps {
+    components?: InspectorComponentMap;
+    field: EditorFieldDescriptor;
+    help?: ReactNode;
+    label?: ReactNode;
+    max?: number;
+    min?: number;
+    onChange: (value: unknown) => void;
+    options?: readonly InspectorSelectOption[];
+    render?: (context: FieldControlRenderContext) => ReactNode;
+    renderUnsupported?: (context: FieldControlRenderContext) => ReactNode;
+    step?: number;
+    value: unknown;
+}
+export interface InspectorFieldOverride {
+    help?: ReactNode;
+    label?: ReactNode;
+    max?: number;
+    min?: number;
+    options?: readonly InspectorSelectOption[];
+    render?: (context: FieldControlRenderContext) => ReactNode;
+    renderUnsupported?: (context: FieldControlRenderContext) => ReactNode;
+    step?: number;
+}
+export interface InspectorFromManifestProps<T extends UnknownRecord> {
+    attributes: T;
+    children?: ReactNode;
+    components?: InspectorComponentMap;
+    fieldLookup: UseEditorFieldsResult;
+    fieldOverrides?: Record<string, InspectorFieldOverride>;
+    initialOpen?: boolean;
+    onChange: (path: string, value: unknown) => void;
+    paths: readonly string[];
+    title?: ReactNode;
+}
+export declare function useEditorFields(manifest: ManifestDocument, options?: EditorModelOptions): UseEditorFieldsResult;
+export declare function useTypedAttributeUpdater<T extends object>(attributes: T, setAttributes: (attrs: Partial<T>) => void, validate?: (value: T) => ValidationResult<T>): TypedAttributeUpdater<T>;
+export declare function FieldControl({ components, field, help, label, max, min, onChange, options, render, renderUnsupported, step, value, }: FieldControlProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function InspectorFromManifest<T extends UnknownRecord>({ attributes, children, components, fieldLookup, fieldOverrides, initialOpen, onChange, paths, title, }: InspectorFromManifestProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/inspector-runtime.js

@@ -0,0 +1,283 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState, } from "react";
+import { createEditorModel, } from "./editor.js";
+import { createAttributeUpdater, createNestedAttributeUpdater, } from "./validation.js";
+import { isPlainObject as isRecord } from "./object-utils.js";
+function getPathSegments(path) {
+    return path.split(".").filter(Boolean);
+}
+function getDefaultValue(field, fallback) {
+    if (field?.hasDefault) {
+        return field.defaultValue;
+    }
+    return fallback;
+}
+function getValueAtPath(source, path) {
+    return getPathSegments(path).reduce((current, segment) => {
+        if (!isRecord(current)) {
+            return undefined;
+        }
+        return current[segment];
+    }, source);
+}
+function toStringValue(value, fallback) {
+    return typeof value === "string" ? value : fallback;
+}
+function toNumberValue(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function toBooleanValue(value, fallback) {
+    return typeof value === "boolean" ? value : fallback;
+}
+function toSelectOptions(options, labelMap) {
+    return options.map((option) => ({
+        label: labelMap?.[String(option.value)] ?? option.label,
+        value: String(option.value),
+    }));
+}
+function createValidationResult(value) {
+    return {
+        data: value,
+        errors: [],
+        isValid: true,
+    };
+}
+function asComponent(value) {
+    if (typeof value === "function" ||
+        (value !== null && typeof value === "object")) {
+        return value;
+    }
+    return undefined;
+}
+function FallbackPanelBody({ children }) {
+    return _jsx(_Fragment, { children: children });
+}
+function getGlobalInspectorComponents() {
+    const globalScope = globalThis;
+    const componentRegistry = globalScope.wp?.components ?? globalScope.window?.wp?.components ?? {};
+    return {
+        PanelBody: asComponent(componentRegistry.PanelBody),
+        RangeControl: asComponent(componentRegistry.RangeControl),
+        SelectControl: asComponent(componentRegistry.SelectControl),
+        TextControl: asComponent(componentRegistry.TextControl),
+        TextareaControl: asComponent(componentRegistry.TextareaControl),
+        ToggleControl: asComponent(componentRegistry.ToggleControl),
+    };
+}
+function resolveInspectorComponents(components) {
+    return {
+        ...getGlobalInspectorComponents(),
+        ...(components ?? {}),
+    };
+}
+function getFieldValue(field, source) {
+    const currentValue = getValueAtPath(source, field.path);
+    if (currentValue !== undefined) {
+        return currentValue;
+    }
+    switch (field.control) {
+        case "toggle":
+            return getDefaultValue(field, false);
+        case "number":
+        case "range":
+            return getDefaultValue(field, 0);
+        case "select":
+        case "text":
+        case "textarea":
+            return getDefaultValue(field, "");
+        default:
+            return getDefaultValue(field, undefined);
+    }
+}
+function getFieldControlContext(field, props, resolvedComponents) {
+    return {
+        components: resolvedComponents,
+        field,
+        help: props.help,
+        label: props.label ?? field.label,
+        max: props.max ?? field.maximum ?? undefined,
+        min: props.min ?? field.minimum ?? undefined,
+        onChange: props.onChange,
+        options: props.options,
+        step: props.step ?? field.step ?? undefined,
+        value: props.value,
+    };
+}
+function parseSelectValue(field, value, overrideOptions) {
+    const matchedOption = field.options.find((option) => String(option.value) === value);
+    if (matchedOption) {
+        return matchedOption.value;
+    }
+    if (overrideOptions?.some((option) => option.value === value)) {
+        return value;
+    }
+    return value;
+}
+function formatNumberDraft(value) {
+    return String(toNumberValue(value, 0));
+}
+function parseNumberDraft(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return undefined;
+    }
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function NumberFieldControl({ context, onChange, value, TextControl, }) {
+    const committedDraft = formatNumberDraft(value);
+    const [draft, setDraft] = useState(committedDraft);
+    useEffect(() => {
+        setDraft(committedDraft);
+    }, [committedDraft]);
+    const commitDraft = useCallback(() => {
+        const parsed = parseNumberDraft(draft);
+        if (parsed === undefined) {
+            setDraft(committedDraft);
+            return;
+        }
+        onChange(parsed);
+        setDraft(String(parsed));
+    }, [committedDraft, draft, onChange]);
+    return (_jsx(TextControl, { help: context.help, label: context.label, max: context.max, min: context.min, onBlur: commitDraft, onChange: setDraft, step: context.step, type: "number", value: draft }));
+}
+export function useEditorFields(manifest, options = {}) {
+    const optionsKey = JSON.stringify({
+        hidden: options.hidden ?? [],
+        labels: options.labels ?? {},
+        manual: options.manual ?? [],
+        preferTextarea: options.preferTextarea ?? [],
+    });
+    const stableOptions = useMemo(() => JSON.parse(optionsKey), [optionsKey]);
+    const fields = useMemo(() => createEditorModel(manifest, stableOptions), [manifest, stableOptions]);
+    const fieldMap = useMemo(() => new Map(fields.map((field) => [field.path, field])), [fields]);
+    const supportedFields = useMemo(() => fields.filter((field) => field.supported), [fields]);
+    const manualFields = useMemo(() => fields.filter((field) => !field.supported), [fields]);
+    const getField = (path) => fieldMap.get(path);
+    const getStringValue = (source, path, fallback) => toStringValue(getValueAtPath(source, path) ?? getDefaultValue(getField(path), fallback), fallback);
+    const getNumberValue = (source, path, fallback) => toNumberValue(getValueAtPath(source, path) ?? getDefaultValue(getField(path), fallback), fallback);
+    const getBooleanValue = (source, path, fallback) => toBooleanValue(getValueAtPath(source, path) ?? getDefaultValue(getField(path), fallback), fallback);
+    const getSelectOptions = (path, labelMap) => toSelectOptions(getField(path)?.options ?? [], labelMap);
+    return {
+        fields,
+        fieldMap,
+        getBooleanValue,
+        getField,
+        getNumberValue,
+        getSelectOptions,
+        getStringValue,
+        manualFields,
+        supportedFields,
+    };
+}
+export function useTypedAttributeUpdater(attributes, setAttributes, validate) {
+    const validateAttributes = useMemo(() => validate ?? ((value) => createValidationResult(value)), [validate]);
+    const updateAttribute = useMemo(() => createAttributeUpdater(attributes, setAttributes, validateAttributes), [attributes, setAttributes, validateAttributes]);
+    const updatePath = useMemo(() => createNestedAttributeUpdater(attributes, setAttributes, validateAttributes), [attributes, setAttributes, validateAttributes]);
+    const updateField = useCallback((path, value) => {
+        if (typeof path === "string" && path.includes(".")) {
+            return updatePath(path, value);
+        }
+        return updateAttribute(path, value);
+    }, [updateAttribute, updatePath]);
+    return {
+        updateAttribute,
+        updateField,
+        updatePath,
+    };
+}
+export function FieldControl({ components, field, help, label, max, min, onChange, options, render, renderUnsupported, step, value, }) {
+    const resolvedComponents = resolveInspectorComponents(components);
+    const context = getFieldControlContext(field, {
+        help,
+        label,
+        max,
+        min,
+        onChange,
+        options,
+        step,
+        value,
+    }, resolvedComponents);
+    if (render) {
+        return _jsx(_Fragment, { children: render(context) });
+    }
+    if (!field.supported) {
+        return renderUnsupported ? _jsx(_Fragment, { children: renderUnsupported(context) }) : null;
+    }
+    switch (field.control) {
+        case "toggle": {
+            const ToggleControl = resolvedComponents.ToggleControl;
+            if (!ToggleControl) {
+                return null;
+            }
+            return (_jsx(ToggleControl, { checked: toBooleanValue(value, false), help: context.help, label: context.label, onChange: (nextValue) => {
+                    onChange(nextValue);
+                } }));
+        }
+        case "select": {
+            const SelectControl = resolvedComponents.SelectControl;
+            if (!SelectControl) {
+                return null;
+            }
+            const selectOptions = context.options ?? toSelectOptions(field.options);
+            return (_jsx(SelectControl, { help: context.help, label: context.label, onChange: (nextValue) => {
+                    onChange(parseSelectValue(field, nextValue, context.options));
+                }, options: selectOptions, value: String(value ?? "") }));
+        }
+        case "range": {
+            const RangeControl = resolvedComponents.RangeControl;
+            if (!RangeControl) {
+                return null;
+            }
+            return (_jsx(RangeControl, { help: context.help, label: context.label, max: context.max, min: context.min, onChange: (nextValue) => {
+                    if (typeof nextValue === "number" && Number.isFinite(nextValue)) {
+                        onChange(nextValue);
+                    }
+                }, step: context.step, value: toNumberValue(value, 0) }));
+        }
+        case "number": {
+            const TextControl = resolvedComponents.TextControl;
+            if (!TextControl) {
+                return null;
+            }
+            return (_jsx(NumberFieldControl, { context: context, onChange: onChange, TextControl: TextControl, value: value }));
+        }
+        case "textarea": {
+            const TextareaControl = resolvedComponents.TextareaControl;
+            if (!TextareaControl) {
+                return null;
+            }
+            return (_jsx(TextareaControl, { help: context.help, label: context.label, onChange: (nextValue) => {
+                    onChange(nextValue);
+                }, value: toStringValue(value, "") }));
+        }
+        case "text": {
+            const TextControl = resolvedComponents.TextControl;
+            if (!TextControl) {
+                return null;
+            }
+            return (_jsx(TextControl, { help: context.help, label: context.label, onChange: (nextValue) => {
+                    onChange(nextValue);
+                }, value: toStringValue(value, "") }));
+        }
+        default:
+            return renderUnsupported ? _jsx(_Fragment, { children: renderUnsupported(context) }) : null;
+    }
+}
+export function InspectorFromManifest({ attributes, children, components, fieldLookup, fieldOverrides, initialOpen, onChange, paths, title, }) {
+    const resolvedComponents = resolveInspectorComponents(components);
+    const PanelBody = resolvedComponents.PanelBody ?? FallbackPanelBody;
+    const fieldControls = paths
+        .map((path) => {
+        const field = fieldLookup.getField(path);
+        if (!field) {
+            return null;
+        }
+        const overrides = fieldOverrides?.[path];
+        return (_jsx(FieldControl, { components: resolvedComponents, field: field, help: overrides?.help, label: overrides?.label, max: overrides?.max, min: overrides?.min, onChange: (value) => {
+                onChange(path, value);
+            }, options: overrides?.options, render: overrides?.render, renderUnsupported: overrides?.renderUnsupported, step: overrides?.step, value: getFieldValue(field, attributes) }, path));
+    })
+        .filter(Boolean);
+    return (_jsxs(PanelBody, { initialOpen: initialOpen, title: title, children: [fieldControls, children] }));
+}

package/dist/inspector.d.ts

@@ -1 +1 @@
-export * from "@wp-typia/create/runtime/inspector";
+export * from "./inspector-runtime.js";

package/dist/inspector.js

@@ -1 +1 @@
-export * from "@wp-typia/create/runtime/inspector";
+export * from "./inspector-runtime.js";

package/dist/json-utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Create a deep clone of a JSON-serializable value.
+ *
+ * @param value JSON-compatible data to clone.
+ * @returns A deep-cloned copy created with `JSON.parse(JSON.stringify(...))`.
+ *
+ * Values that are not JSON-serializable, such as functions, `undefined`,
+ * `BigInt`, class instances, and `Date` objects, are not preserved faithfully.
+ */
+export declare function cloneJsonValue<T>(value: T): T;

package/dist/json-utils.js

@@ -0,0 +1,12 @@
+/**
+ * Create a deep clone of a JSON-serializable value.
+ *
+ * @param value JSON-compatible data to clone.
+ * @returns A deep-cloned copy created with `JSON.parse(JSON.stringify(...))`.
+ *
+ * Values that are not JSON-serializable, such as functions, `undefined`,
+ * `BigInt`, class instances, and `Date` objects, are not preserved faithfully.
+ */
+export function cloneJsonValue(value) {
+    return JSON.parse(JSON.stringify(value));
+}

package/dist/metadata-analysis.d.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+export interface AnalysisContext {
+    allowedExternalPackages: Set<string>;
+    checker: ts.TypeChecker;
+    packageNameCache: Map<string, string | null>;
+    projectRoot: string;
+    program: ts.Program;
+    recursionGuard: Set<string>;
+}
+export declare function getTaggedSyncBlockMetadataFailureCode(error: Error): "typescript-diagnostic" | undefined;
+export declare function createAnalysisContext(projectRoot: string, typesFilePath: string): AnalysisContext;