@wp-typia/block-runtime 0.2.3 → 0.4.0

package/dist/metadata-model.d.ts

@@ -0,0 +1,84 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type AttributeKind = "string" | "number" | "boolean" | "array" | "object" | "union";
+export type WordPressAttributeKind = "string" | "number" | "boolean" | "array" | "object";
+export type WordPressAttributeSource = "html" | "text" | "rich-text";
+export interface AttributeConstraints {
+    exclusiveMaximum: number | null;
+    exclusiveMinimum: number | null;
+    format: string | null;
+    maxLength: number | null;
+    maxItems: number | null;
+    maximum: number | null;
+    minLength: number | null;
+    minItems: number | null;
+    minimum: number | null;
+    multipleOf: number | null;
+    pattern: string | null;
+    typeTag: string | null;
+}
+export interface AttributeNode {
+    constraints: AttributeConstraints;
+    defaultValue?: JsonValue;
+    enumValues: Array<string | number | boolean> | null;
+    items?: AttributeNode;
+    kind: AttributeKind;
+    path: string;
+    properties?: Record<string, AttributeNode>;
+    required: boolean;
+    union?: AttributeUnion | null;
+    wp: {
+        selector: string | null;
+        source: WordPressAttributeSource | null;
+    };
+}
+export interface AttributeUnion {
+    branches: Record<string, AttributeNode>;
+    discriminator: string;
+}
+export interface BlockJsonAttribute {
+    default?: JsonValue;
+    enum?: Array<string | number | boolean>;
+    selector?: string;
+    source?: WordPressAttributeSource;
+    type: WordPressAttributeKind;
+}
+export interface ManifestAttribute {
+    typia: {
+        constraints: AttributeConstraints;
+        defaultValue: JsonValue | null;
+        hasDefault: boolean;
+    };
+    ts: {
+        items: ManifestAttribute | null;
+        kind: AttributeKind;
+        properties: Record<string, ManifestAttribute> | null;
+        required: boolean;
+        union: ManifestUnion | null;
+    };
+    wp: {
+        defaultValue: JsonValue | null;
+        enum: Array<string | number | boolean> | null;
+        hasDefault: boolean;
+        selector?: string | null;
+        source?: WordPressAttributeSource | null;
+        type: WordPressAttributeKind;
+    };
+}
+export interface ManifestUnion {
+    branches: Record<string, ManifestAttribute>;
+    discriminator: string;
+}
+export interface ManifestDocument {
+    attributes: Record<string, ManifestAttribute>;
+    manifestVersion: 2;
+    sourceType: string;
+}
+export declare function defaultAttributeConstraints(): AttributeConstraints;
+export declare function getWordPressKind(node: AttributeNode): WordPressAttributeKind;
+export declare function baseNode(kind: AttributeKind, pathLabel: string): AttributeNode;
+export declare function withRequired(node: AttributeNode, required: boolean): AttributeNode;
+export declare function cloneUnion(union: AttributeUnion): AttributeUnion;
+export declare function cloneProperties(properties: Record<string, AttributeNode>): Record<string, AttributeNode>;

package/dist/metadata-model.js

@@ -0,0 +1,59 @@
+export function defaultAttributeConstraints() {
+    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,
+    };
+}
+export function getWordPressKind(node) {
+    return node.kind === "union" ? "object" : node.kind;
+}
+export function baseNode(kind, pathLabel) {
+    return {
+        constraints: defaultAttributeConstraints(),
+        enumValues: null,
+        kind,
+        path: pathLabel,
+        required: true,
+        union: null,
+        wp: {
+            selector: null,
+            source: null,
+        },
+    };
+}
+export function withRequired(node, required) {
+    return {
+        ...node,
+        items: node.items
+            ? withRequired(node.items, node.items.required)
+            : undefined,
+        properties: node.properties ? cloneProperties(node.properties) : undefined,
+        required,
+        union: node.union ? cloneUnion(node.union) : null,
+    };
+}
+export function cloneUnion(union) {
+    return {
+        branches: Object.fromEntries(Object.entries(union.branches).map(([key, branch]) => [
+            key,
+            withRequired(branch, branch.required),
+        ])),
+        discriminator: union.discriminator,
+    };
+}
+export function cloneProperties(properties) {
+    return Object.fromEntries(Object.entries(properties).map(([key, node]) => [
+        key,
+        withRequired(node, node.required),
+    ]));
+}

package/dist/metadata-parser.d.ts

@@ -0,0 +1,53 @@
+import ts from "typescript";
+import { type AnalysisContext } from "./metadata-analysis.js";
+import { type AttributeNode } from "./metadata-model.js";
+/**
+ * Analyze one named source type from a TypeScript module.
+ *
+ * @param options Metadata analysis options including the project root, source
+ * type name, and types file path.
+ * @returns The resolved project root plus the parsed root attribute node for
+ * the requested source type.
+ */
+export declare function analyzeSourceType(options: {
+    projectRoot?: string;
+    sourceTypeName: string;
+    typesFile: string;
+}): {
+    projectRoot: string;
+    rootNode: AttributeNode;
+};
+/**
+ * Analyze multiple named source types from a TypeScript module.
+ *
+ * @param options Metadata analysis options including the optional project root
+ * and the relative types file path to parse.
+ * @param sourceTypeNames Exported type or interface names to resolve from the
+ * configured types file.
+ * @returns A record keyed by source type name with parsed attribute-node trees
+ * for each requested type.
+ */
+export declare function analyzeSourceTypes(options: {
+    projectRoot?: string;
+    typesFile: string;
+}, sourceTypeNames: string[]): Record<string, AttributeNode>;
+/**
+ * Parse an interface or type alias declaration into one attribute-node tree.
+ *
+ * @param declaration TypeScript declaration node to parse.
+ * @param ctx Shared analysis context used for type resolution and recursion
+ * detection.
+ * @param pathLabel Human-readable path label for diagnostics.
+ * @param required Whether the resulting node should be marked as required.
+ * @returns The parsed attribute-node representation for the declaration.
+ */
+export declare function parseNamedDeclaration(declaration: ts.InterfaceDeclaration | ts.TypeAliasDeclaration, ctx: AnalysisContext, pathLabel: string, required: boolean): AttributeNode;
+/**
+ * Parse one TypeScript type node into the internal metadata model.
+ *
+ * @param node TypeScript AST node describing the source type shape.
+ * @param ctx Shared analysis context used for symbol and type resolution.
+ * @param pathLabel Human-readable path label used in parse errors and warnings.
+ * @returns The parsed attribute-node representation of the provided type node.
+ */
+export declare function parseTypeNode(node: ts.TypeNode, ctx: AnalysisContext, pathLabel: string): AttributeNode;