@world-engines/blocks-editor 0.1.0

package/dist/fields/register.d.ts

@@ -0,0 +1,6 @@
+export declare const FIELD_ENTITY_PICKER: "field_entity_picker";
+export declare const FIELD_ATTR_PICKER: "field_attr_picker";
+export declare const FIELD_EDGE_PICKER: "field_edge_picker";
+export declare const FIELD_STATE_PICKER: "field_state_picker";
+export declare const FIELD_TIME_PICKER: "field_time_picker";
+export declare function registerPickerFieldsOnce(): void;

package/dist/fields/register.js

@@ -0,0 +1,22 @@
+import * as Blockly from "blockly";
+import { AttrPickerField } from "./AttrPickerField.js";
+import { EdgePickerField } from "./EdgePickerField.js";
+import { EntityPickerField } from "./EntityPickerField.js";
+import { StatePickerField } from "./StatePickerField.js";
+import { TimePickerField } from "./TimePickerField.js";
+export const FIELD_ENTITY_PICKER = "field_entity_picker";
+export const FIELD_ATTR_PICKER = "field_attr_picker";
+export const FIELD_EDGE_PICKER = "field_edge_picker";
+export const FIELD_STATE_PICKER = "field_state_picker";
+export const FIELD_TIME_PICKER = "field_time_picker";
+let registered = false;
+export function registerPickerFieldsOnce() {
+    if (registered)
+        return;
+    Blockly.fieldRegistry.register(FIELD_ENTITY_PICKER, EntityPickerField);
+    Blockly.fieldRegistry.register(FIELD_ATTR_PICKER, AttrPickerField);
+    Blockly.fieldRegistry.register(FIELD_EDGE_PICKER, EdgePickerField);
+    Blockly.fieldRegistry.register(FIELD_STATE_PICKER, StatePickerField);
+    Blockly.fieldRegistry.register(FIELD_TIME_PICKER, TimePickerField);
+    registered = true;
+}

package/dist/i18n/messages-zh.d.ts

@@ -0,0 +1,6 @@
+interface BlocklyLocaleSink {
+    readonly setLocale: (locale: Record<string, string>) => void;
+}
+export declare function buildZhMessages(): Record<string, string>;
+export declare function applyZhMessages(target: BlocklyLocaleSink): void;
+export {};

package/dist/i18n/messages-zh.js

@@ -0,0 +1,34 @@
+// Blockly 发布了该运行时子路径 但未在 exports 中提供类型声明。
+// @ts-ignore 上游不同安装形态对 blockly/msg/zh-hans 的声明可用性不一致
+import * as blocklyZhHans from "blockly/msg/zh-hans";
+const TERM_OVERRIDES = {
+    DUPLICATE_BLOCK: "复制积木",
+    DELETE_BLOCK: "删除积木",
+    DELETE_X_BLOCKS: "删除 %1 个积木",
+    DELETE_ALL_BLOCKS: "删除所有积木 (%1 个)?",
+    CLEAN_UP: "整理积木",
+    COLLAPSE_BLOCK: "折叠积木",
+    COLLAPSE_ALL: "折叠所有积木",
+    EXPAND_BLOCK: "展开积木",
+    EXPAND_ALL: "展开所有积木",
+    DISABLE_BLOCK: "禁用积木",
+    ENABLE_BLOCK: "启用积木",
+    INLINE_INPUTS: "内联输入",
+    EXTERNAL_INPUTS: "外置输入",
+    HELP: "帮助",
+    UNDO: "撤销",
+    REDO: "重做"
+};
+export function buildZhMessages() {
+    const source = blocklyZhHans;
+    const base = {};
+    for (const key of Object.keys(source)) {
+        const value = source[key];
+        if (typeof value === "string")
+            base[key] = value;
+    }
+    return { ...base, ...TERM_OVERRIDES };
+}
+export function applyZhMessages(target) {
+    target.setLocale(buildZhMessages());
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export type { AttrRefLeaf, CloseMode, DaySegment, DaySegmentLeaf, EventLeaf, LeafId, NlConditionLeaf, RelationRefLeaf, ScenarioEntityMinimal, ScenarioPropMinimal, ScenarioPropValueMinimal, ScenarioRootMinimal, TimeLeaf, TriggerDef, TriggerId, TriggerLeaf, TriggerTree, WorldTimePoint } from "./migration/types.js";
+export { liquidGlassDarkTheme } from "./themes/liquid-glass-dark.js";
+export { parseTmwWorkspaceV3, TMW_CONDITION_BLOCK_TYPES, tmwConditionNodeFromWorkspace, tmwConditionNodeToWorkspace } from "./adapters/trigger.js";
+export type { BlockNode, BlockNodeInputSlot, BlockNodeNextSlot, BlocklyWorkspaceJson } from "./adapters/trigger.js";
+export type { BlocksConditionExpressionV3, BlocksTriggerConditionNodeV3 } from "./adapters/trigger.js";
+export { BlocksWorkspace, CATEGORY_IDS } from "./workspace.js";
+export type { BlocksWorkspaceHandle, BlocksWorkspaceProps, BlocksWorkspaceSchema, BlocksWorkspaceTriggerCtx, CategoryId } from "./workspace.js";
+export type { BlocksEditorCtx, CtxEdge, CtxEntity, CtxEntityAttr, CtxEntityState, CtxEvent, CtxVariable } from "./blocks/ctx.js";
+export { buildToolbox, getToolbox, listToolboxCategoryIds, listToolboxCategoryNames, categoryDisplayNameOf } from "./blocks/toolbox.js";
+export type { ToolboxJson, ToolboxCategoryEntry } from "./blocks/toolbox.js";
+export { HAT_TYPES, HAT_BLOCK_TYPES, isHatType, CONTROL_STATEMENT_TYPES, SENSING_REPORTER_TYPES, OPERATOR_BOOLEAN_TYPES, OPERATOR_NUMBER_TYPES, OPERATOR_STRING_TYPES, VARIABLE_TYPES, ENTITY_OP_TYPES, TIME_OP_TYPES } from "./blocks/registry-taxonomy.js";
+export { EMPTY_SDK_CATALOG, parseSdkCatalogFromSource, registerSdkBlocks, SDK_BLOCK_PREFIX } from "./sdk-to-block/index.js";
+export type { SdkArg, SdkArgType, SdkBlockCategory, SdkBlockKind, SdkCatalog, SdkEnumType, SdkFunctionSignature, SdkPickerType, SdkPrimitiveType, SdkReturnType } from "./sdk-to-block/index.js";
+export { PickerHost } from "./react/PickerHost.js";
+export { PICKER_EVENT_NAME } from "./fields/picker-events.js";
+export type { PickerCandidate, PickerKind, PickerRequestDetail } from "./fields/picker-events.js";
+export { FIELD_ATTR_PICKER, FIELD_EDGE_PICKER, FIELD_ENTITY_PICKER, FIELD_STATE_PICKER, FIELD_TIME_PICKER } from "./fields/register.js";
+export { registerViewBlocks, viewBlockType } from "./view-to-block/index.js";
+export type { ViewBlockCatalog } from "./view-to-block/index.js";
+export { beginTmwBuilder, TmwBuilder } from "@world-engines/tmw/builder";
+export type { TriggerDocumentV3, TriggerNodeV3 } from "@world-engines/tmw";

package/dist/index.js

@@ -0,0 +1,11 @@
+export { liquidGlassDarkTheme } from "./themes/liquid-glass-dark.js";
+export { parseTmwWorkspaceV3, TMW_CONDITION_BLOCK_TYPES, tmwConditionNodeFromWorkspace, tmwConditionNodeToWorkspace } from "./adapters/trigger.js";
+export { BlocksWorkspace, CATEGORY_IDS } from "./workspace.js";
+export { buildToolbox, getToolbox, listToolboxCategoryIds, listToolboxCategoryNames, categoryDisplayNameOf } from "./blocks/toolbox.js";
+export { HAT_TYPES, HAT_BLOCK_TYPES, isHatType, CONTROL_STATEMENT_TYPES, SENSING_REPORTER_TYPES, OPERATOR_BOOLEAN_TYPES, OPERATOR_NUMBER_TYPES, OPERATOR_STRING_TYPES, VARIABLE_TYPES, ENTITY_OP_TYPES, TIME_OP_TYPES } from "./blocks/registry-taxonomy.js";
+export { EMPTY_SDK_CATALOG, parseSdkCatalogFromSource, registerSdkBlocks, SDK_BLOCK_PREFIX } from "./sdk-to-block/index.js";
+export { PickerHost } from "./react/PickerHost.js";
+export { PICKER_EVENT_NAME } from "./fields/picker-events.js";
+export { FIELD_ATTR_PICKER, FIELD_EDGE_PICKER, FIELD_ENTITY_PICKER, FIELD_STATE_PICKER, FIELD_TIME_PICKER } from "./fields/register.js";
+export { registerViewBlocks, viewBlockType } from "./view-to-block/index.js";
+export { beginTmwBuilder, TmwBuilder } from "@world-engines/tmw/builder";

package/dist/migration/index.d.ts

@@ -0,0 +1 @@
+export type { AttrRefLeaf, CloseMode, DaySegment, DaySegmentLeaf, EventLeaf, LeafId, NlConditionLeaf, RelationRefLeaf, ScenarioEntityMinimal, ScenarioPropMinimal, ScenarioPropValueMinimal, ScenarioRootMinimal, TimeLeaf, TriggerDef, TriggerId, TriggerLeaf, TriggerTree, WorldTimePoint, } from "./types.js";

package/dist/migration/index.js

@@ -0,0 +1 @@
+export {};

package/dist/migration/types.d.ts

@@ -0,0 +1,91 @@
+export interface WorldTimePoint {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    readonly hour: number;
+    readonly minute: number;
+    readonly second: number;
+}
+export type LeafId = string;
+export type TriggerId = string;
+export type CloseMode = "permanent" | "temporary";
+export interface TimeLeaf {
+    readonly leaf: "time";
+    readonly leaf_id: LeafId;
+    readonly at: WorldTimePoint;
+}
+export interface EventLeaf {
+    readonly leaf: "event";
+    readonly leaf_id: LeafId;
+    readonly event_id: string;
+    readonly delay_ms?: number;
+}
+export interface NlConditionLeaf {
+    readonly leaf: "nl_condition";
+    readonly leaf_id: LeafId;
+    readonly text: string;
+    readonly milestone?: boolean;
+    readonly delay_ms?: number;
+}
+export interface AttrRefLeaf {
+    readonly leaf: "attr_ref";
+    readonly leaf_id: LeafId;
+    readonly entity_id: string;
+    readonly attr_key: string;
+    readonly expected_value?: string;
+    readonly delay_ms?: number;
+}
+export interface RelationRefLeaf {
+    readonly leaf: "relation_ref";
+    readonly leaf_id: LeafId;
+    readonly src_id: string;
+    readonly dst_id: string;
+    readonly kind: string;
+    readonly attr_key: string;
+    readonly expected_value?: string;
+    readonly delay_ms?: number;
+}
+export type DaySegment = "morning" | "forenoon" | "afternoon" | "night";
+export interface DaySegmentLeaf {
+    readonly leaf: "day_segment";
+    readonly leaf_id: LeafId;
+    readonly segment: DaySegment;
+}
+export type TriggerLeaf = TimeLeaf | EventLeaf | NlConditionLeaf | AttrRefLeaf | RelationRefLeaf | DaySegmentLeaf;
+export type TriggerTree = {
+    readonly op: "and";
+    readonly children: ReadonlyArray<TriggerTree>;
+} | {
+    readonly op: "or";
+    readonly children: ReadonlyArray<TriggerTree>;
+} | {
+    readonly op: "not";
+    readonly child: TriggerTree;
+} | TriggerLeaf;
+export interface TriggerDef {
+    readonly id: TriggerId;
+    readonly name?: string;
+    readonly description?: string;
+    readonly tree: TriggerTree;
+    readonly close_when?: TriggerTree;
+    readonly close_mode?: CloseMode;
+}
+export type ScenarioPropValueMinimal = string | ReadonlyArray<string> | {
+    readonly [subKey: string]: ScenarioPropMinimal;
+};
+export interface ScenarioPropMinimal {
+    readonly value: ScenarioPropValueMinimal;
+    readonly trigger?: TriggerDef;
+    readonly states?: ReadonlyArray<unknown>;
+}
+export interface ScenarioEntityMinimal {
+    readonly id: string;
+    readonly trigger?: TriggerDef;
+    readonly props?: {
+        readonly [key: string]: ScenarioPropMinimal;
+    };
+}
+export interface ScenarioRootMinimal {
+    readonly schemaVersion?: number;
+    readonly entities: ReadonlyArray<ScenarioEntityMinimal>;
+}

package/dist/migration/types.js

@@ -0,0 +1 @@
+export {};

package/dist/react/PickerHost.d.ts

@@ -0,0 +1,6 @@
+import type { ReactElement } from "react";
+interface PickerHostProps {
+    readonly className?: string;
+}
+export declare function PickerHost(_props?: PickerHostProps): ReactElement | null;
+export {};

package/dist/react/PickerHost.js

@@ -0,0 +1,110 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { createPortal } from "react-dom";
+import { PICKER_EVENT_NAME } from "../fields/picker-events.js";
+const OVERLAY_STYLE = {
+    position: "fixed",
+    inset: 0,
+    background: "rgba(0, 0, 0, 0.5)",
+    zIndex: 9999,
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center"
+};
+const MODAL_STYLE = {
+    background: "rgba(20, 20, 30, 0.95)",
+    color: "rgba(232, 236, 246, 0.92)",
+    borderRadius: "12px",
+    padding: "1rem",
+    minWidth: "20rem",
+    maxWidth: "min(90vw, 32rem)",
+    maxHeight: "70vh",
+    overflow: "hidden",
+    display: "flex",
+    flexDirection: "column",
+    gap: "0.75rem",
+    boxShadow: "0 1rem 3rem rgba(0, 0, 0, 0.6)"
+};
+const LIST_STYLE = {
+    listStyle: "none",
+    margin: 0,
+    padding: 0,
+    overflowY: "auto",
+    maxHeight: "50vh",
+    display: "flex",
+    flexDirection: "column",
+    gap: "0.25rem"
+};
+const ITEM_STYLE = {
+    padding: "0.5rem 0.75rem",
+    borderRadius: "6px",
+    cursor: "pointer",
+    background: "rgba(255, 255, 255, 0.04)",
+    border: "1px solid transparent"
+};
+const ITEM_ACTIVE_STYLE = {
+    ...ITEM_STYLE,
+    background: "rgba(106, 227, 251, 0.15)",
+    borderColor: "rgba(106, 227, 251, 0.5)"
+};
+const HEADER_STYLE = {
+    fontSize: "0.95rem",
+    fontWeight: 600,
+    margin: 0
+};
+const FOOTER_STYLE = {
+    display: "flex",
+    justifyContent: "flex-end",
+    gap: "0.5rem"
+};
+const BUTTON_STYLE = {
+    padding: "0.375rem 0.75rem",
+    borderRadius: "6px",
+    border: "1px solid rgba(255,255,255,0.15)",
+    background: "transparent",
+    color: "inherit",
+    cursor: "pointer"
+};
+const EMPTY_STYLE = {
+    padding: "1rem",
+    textAlign: "center",
+    color: "rgba(232, 236, 246, 0.5)",
+    fontSize: "0.85rem"
+};
+export function PickerHost(_props = {}) {
+    const [request, setRequest] = useState(null);
+    useEffect(() => {
+        const handler = (ev) => {
+            const detail = ev.detail;
+            if (!detail)
+                return;
+            setRequest(detail);
+        };
+        window.addEventListener(PICKER_EVENT_NAME, handler);
+        return () => window.removeEventListener(PICKER_EVENT_NAME, handler);
+    }, []);
+    if (request === null)
+        return null;
+    if (typeof document === "undefined")
+        return null;
+    const handleCancel = () => {
+        request.onCancel?.();
+        setRequest(null);
+    };
+    const handleSelect = (value) => {
+        request.onSelect(value);
+        setRequest(null);
+    };
+    return createPortal(_jsx("div", { style: OVERLAY_STYLE, onClick: (ev) => {
+            if (ev.target === ev.currentTarget)
+                handleCancel();
+        }, role: "presentation", children: _jsxs("div", { style: MODAL_STYLE, role: "dialog", "aria-modal": "true", "aria-label": request.title, children: [_jsx("h3", { style: HEADER_STYLE, children: request.title }), request.candidates.length === 0 ? (_jsx("div", { style: EMPTY_STYLE, children: "\u6682\u65E0\u53EF\u9009\u9879 \u8BF7\u5148\u5728\u56FE\u8C31\u5185\u521B\u5EFA" })) : (_jsx("ul", { style: LIST_STYLE, children: request.candidates.map((c) => {
+                        const active = c.id === request.currentValue;
+                        return (_jsxs("li", { style: active ? ITEM_ACTIVE_STYLE : ITEM_STYLE, onClick: () => handleSelect(c.id), role: "button", tabIndex: 0, onKeyDown: (ev) => {
+                                if (ev.key === "Enter" || ev.key === " ") {
+                                    ev.preventDefault();
+                                    handleSelect(c.id);
+                                }
+                            }, children: [_jsx("div", { style: { fontWeight: 500 }, children: c.name }), c.subtitle !== undefined && (_jsx("div", { style: { fontSize: "0.75rem", opacity: 0.6 }, children: c.subtitle }))] }, c.id));
+                    }) })), _jsx("div", { style: FOOTER_STYLE, children: _jsx("button", { type: "button", style: BUTTON_STYLE, onClick: handleCancel, children: "\u53D6\u6D88" }) })] }) }), document.body);
+}

package/dist/sdk-to-block/index.d.ts

@@ -0,0 +1,4 @@
+export { EMPTY_SDK_CATALOG, isEnumType, isPickerType, type SdkArg, type SdkArgType, type SdkBlockCategory, type SdkBlockKind, type SdkCatalog, type SdkEnumType, type SdkFunctionSignature, type SdkPickerType, type SdkPrimitiveType, type SdkReturnType } from "./signature.js";
+export { toBlockDef, SDK_BLOCK_PREFIX, type BlockDefJson } from "./to-block-def.js";
+export { listRegisteredSdkBlockTypes, registerSdkBlocks } from "./register.js";
+export { parseSdkCatalogFromSource } from "./parser.js";

package/dist/sdk-to-block/index.js

@@ -0,0 +1,4 @@
+export { EMPTY_SDK_CATALOG, isEnumType, isPickerType } from "./signature.js";
+export { toBlockDef, SDK_BLOCK_PREFIX } from "./to-block-def.js";
+export { listRegisteredSdkBlockTypes, registerSdkBlocks } from "./register.js";
+export { parseSdkCatalogFromSource } from "./parser.js";

package/dist/sdk-to-block/parser.d.ts

@@ -0,0 +1,2 @@
+import type { SdkCatalog } from "./signature.js";
+export declare function parseSdkCatalogFromSource(source: string): SdkCatalog;

package/dist/sdk-to-block/parser.js

@@ -0,0 +1,101 @@
+const FUNC_REGEX = /export\s+(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)\s*:\s*([^\{;]+)/g;
+const stripParens = (s) => s.trim().replace(/^\(|\)$/g, "");
+const parseReturnType = (raw) => {
+    const trim = raw.trim().replace(/\s+/g, "");
+    if (trim.startsWith("void") || trim.startsWith("Promise<void>"))
+        return "void";
+    const inner = trim.startsWith("Promise<")
+        ? trim.slice("Promise<".length, -1)
+        : trim;
+    if (inner === "boolean")
+        return "boolean";
+    if (inner === "number")
+        return "number";
+    if (inner === "string")
+        return "string";
+    if (inner === "object" || inner === "unknown")
+        return "object";
+    return "any";
+};
+const mapArgType = (raw) => {
+    const trim = raw.trim();
+    if (trim === "string")
+        return "string";
+    if (trim === "number")
+        return "number";
+    if (trim === "boolean")
+        return "boolean";
+    if (trim === "object" || trim === "unknown")
+        return "object";
+    if (trim === "EntityId" || trim === "entity_id")
+        return "entity_id";
+    if (trim === "AttrRef" || trim === "attr_ref")
+        return "attr_ref";
+    if (trim === "EdgeRef" || trim === "edge_ref")
+        return "edge_ref";
+    if (trim === "TimeRef" || trim === "time")
+        return "time";
+    if (trim === "VarRef" || trim === "variable")
+        return "variable";
+    const enumMatch = trim.match(/^"([^"]+)"(?:\s*\|\s*"([^"]+)")*$/);
+    if (enumMatch !== null) {
+        const values = Array.from(trim.matchAll(/"([^"]+)"/g)).map((m) => m[1] ?? "");
+        return { enum: values };
+    }
+    return "string";
+};
+const parseArgs = (raw) => {
+    const cleaned = stripParens(raw);
+    if (cleaned.length === 0)
+        return [];
+    const parts = [];
+    let depth = 0;
+    let cur = "";
+    for (const ch of cleaned) {
+        if (ch === "<" || ch === "(" || ch === "{")
+            depth++;
+        else if (ch === ">" || ch === ")" || ch === "}")
+            depth--;
+        if (ch === "," && depth === 0) {
+            parts.push(cur);
+            cur = "";
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur.trim().length > 0)
+        parts.push(cur);
+    const args = [];
+    for (const part of parts) {
+        const colonIdx = part.indexOf(":");
+        if (colonIdx < 0)
+            continue;
+        const name = part.slice(0, colonIdx).trim().replace(/[?]$/, "");
+        const typeRaw = part.slice(colonIdx + 1).trim();
+        if (name.length === 0)
+            continue;
+        args.push({ name, label: name, type: mapArgType(typeRaw) });
+    }
+    return args;
+};
+export function parseSdkCatalogFromSource(source) {
+    const functions = [];
+    let m;
+    const regex = new RegExp(FUNC_REGEX.source, "g");
+    while ((m = regex.exec(source)) !== null) {
+        const name = m[1] ?? "";
+        const argsRaw = m[2] ?? "";
+        const retRaw = m[3] ?? "";
+        if (name.length === 0)
+            continue;
+        functions.push({
+            name,
+            label: name,
+            description: "",
+            args: parseArgs(argsRaw),
+            returnType: parseReturnType(retRaw),
+            category: "my_blocks"
+        });
+    }
+    return { version: 1, functions };
+}

package/dist/sdk-to-block/register.d.ts

@@ -0,0 +1,3 @@
+import type { SdkCatalog } from "./signature.js";
+export declare function registerSdkBlocks(catalog: SdkCatalog): ReadonlyArray<string>;
+export declare function listRegisteredSdkBlockTypes(): ReadonlyArray<string>;

package/dist/sdk-to-block/register.js

@@ -0,0 +1,27 @@
+import * as Blockly from "blockly";
+import { registerPickerFieldsOnce } from "../fields/register.js";
+import { SDK_BLOCK_PREFIX, toBlockDef } from "./to-block-def.js";
+const registeredTypes = new Set();
+export function registerSdkBlocks(catalog) {
+    registerPickerFieldsOnce();
+    const types = [];
+    const fresh = catalog.functions.filter((f) => {
+        const type = `${SDK_BLOCK_PREFIX}${f.name}`;
+        if (registeredTypes.has(type))
+            return false;
+        return true;
+    });
+    if (fresh.length > 0) {
+        const defs = fresh.map((sig) => toBlockDef(sig));
+        Blockly.common.defineBlocksWithJsonArray(defs);
+        for (const def of defs)
+            registeredTypes.add(def.type);
+    }
+    for (const sig of catalog.functions) {
+        types.push(`${SDK_BLOCK_PREFIX}${sig.name}`);
+    }
+    return types;
+}
+export function listRegisteredSdkBlockTypes() {
+    return Array.from(registeredTypes);
+}

package/dist/sdk-to-block/signature.d.ts

@@ -0,0 +1,31 @@
+export type SdkPrimitiveType = "string" | "number" | "boolean" | "object";
+export type SdkPickerType = "entity_id" | "attr_ref" | "edge_ref" | "time" | "variable";
+export interface SdkEnumType {
+    readonly enum: ReadonlyArray<string>;
+}
+export type SdkArgType = SdkPrimitiveType | SdkPickerType | SdkEnumType;
+export type SdkReturnType = "void" | "string" | "number" | "boolean" | "object" | "any";
+export type SdkBlockKind = "statement" | "reporter" | "boolean";
+export type SdkBlockCategory = "my_blocks" | "sensing" | "variables";
+export interface SdkArg {
+    readonly name: string;
+    readonly label: string;
+    readonly type: SdkArgType;
+    readonly description?: string;
+}
+export interface SdkFunctionSignature {
+    readonly name: string;
+    readonly label: string;
+    readonly description: string;
+    readonly args: ReadonlyArray<SdkArg>;
+    readonly returnType: SdkReturnType;
+    readonly kind?: SdkBlockKind;
+    readonly category: SdkBlockCategory;
+}
+export interface SdkCatalog {
+    readonly version: number;
+    readonly functions: ReadonlyArray<SdkFunctionSignature>;
+}
+export declare const EMPTY_SDK_CATALOG: SdkCatalog;
+export declare function isEnumType(t: SdkArgType): t is SdkEnumType;
+export declare function isPickerType(t: SdkArgType): t is SdkPickerType;

package/dist/sdk-to-block/signature.js

@@ -0,0 +1,12 @@
+export const EMPTY_SDK_CATALOG = {
+    version: 1,
+    functions: []
+};
+export function isEnumType(t) {
+    return typeof t === "object" && t !== null && "enum" in t;
+}
+export function isPickerType(t) {
+    if (typeof t !== "string")
+        return false;
+    return t === "entity_id" || t === "attr_ref" || t === "edge_ref" || t === "time" || t === "variable";
+}

package/dist/sdk-to-block/to-block-def.d.ts

@@ -0,0 +1,25 @@
+import { type SdkFunctionSignature } from "./signature.js";
+export declare const SDK_BLOCK_PREFIX: "sdk_";
+interface JsonFieldSpec {
+    readonly type: string;
+    readonly name: string;
+    readonly [key: string]: unknown;
+}
+interface JsonInputSpec {
+    readonly type: string;
+    readonly name: string;
+    readonly [key: string]: unknown;
+}
+type JsonArg = JsonFieldSpec | JsonInputSpec;
+export interface BlockDefJson {
+    readonly type: string;
+    readonly message0: string;
+    readonly args0?: ReadonlyArray<JsonArg>;
+    readonly colour: string;
+    readonly tooltip?: string;
+    readonly output?: string | null;
+    readonly previousStatement?: null;
+    readonly nextStatement?: null;
+}
+export declare function toBlockDef(sig: SdkFunctionSignature): BlockDefJson;
+export {};

package/dist/sdk-to-block/to-block-def.js

@@ -0,0 +1,71 @@
+import { FIELD_ATTR_PICKER, FIELD_EDGE_PICKER, FIELD_ENTITY_PICKER, FIELD_TIME_PICKER } from "../fields/register.js";
+import { isEnumType } from "./signature.js";
+import { BLOCK_CATEGORY_PALETTE } from "../themes/liquid-glass-dark.js";
+export const SDK_BLOCK_PREFIX = "sdk_";
+function argToField(a) {
+    const upperName = a.name.toUpperCase();
+    const type = a.type;
+    if (isEnumType(type)) {
+        return {
+            type: "field_dropdown",
+            name: upperName,
+            options: type.enum.map((v) => [v, v])
+        };
+    }
+    switch (type) {
+        case "entity_id":
+            return { type: FIELD_ENTITY_PICKER, name: upperName };
+        case "attr_ref":
+            return { type: FIELD_ATTR_PICKER, name: upperName };
+        case "edge_ref":
+            return { type: FIELD_EDGE_PICKER, name: upperName };
+        case "time":
+            return { type: FIELD_TIME_PICKER, name: upperName };
+        case "variable":
+            return { type: "field_variable", name: upperName };
+        case "string":
+            return { type: "input_value", name: upperName, check: "String" };
+        case "number":
+            return { type: "input_value", name: upperName, check: "Number" };
+        case "boolean":
+            return { type: "input_value", name: upperName, check: "Boolean" };
+        case "object":
+            return { type: "input_value", name: upperName, check: "Object" };
+        default: {
+            const exhaustiveCheck = type;
+            void exhaustiveCheck;
+            return { type: "input_value", name: upperName };
+        }
+    }
+}
+export function toBlockDef(sig) {
+    const args0 = sig.args.map((a) => argToField(a));
+    const parts = sig.args.map((_, i) => `%${i + 1}`);
+    const message0 = parts.length > 0 ? `${sig.label} ${parts.join(" ")}` : sig.label;
+    const type = `${SDK_BLOCK_PREFIX}${sig.name}`;
+    const base = {
+        type,
+        message0,
+        args0,
+        colour: BLOCK_CATEGORY_PALETTE.sdkInterfaces.primary,
+        tooltip: sig.description
+    };
+    const explicitKind = sig.kind;
+    if (explicitKind === "statement") {
+        return { ...base, previousStatement: null, nextStatement: null };
+    }
+    if (explicitKind === "boolean" || sig.returnType === "boolean") {
+        return { ...base, output: "Boolean" };
+    }
+    if (sig.returnType === "object") {
+        return { ...base, output: "Object" };
+    }
+    if (explicitKind === "reporter" || (sig.returnType !== "void" && sig.returnType !== "any")) {
+        const outputType = sig.returnType === "number" ? "Number" : "String";
+        return { ...base, output: outputType };
+    }
+    if (sig.returnType === "any") {
+        return { ...base, output: null };
+    }
+    return { ...base, previousStatement: null, nextStatement: null };
+}

package/dist/themes/index.d.ts

@@ -0,0 +1,4 @@
+import "./liquid-glass.css";
+export { liquidGlassDarkTheme, LIQUID_GLASS_DARK_THEME_NAME, LIQUID_GLASS_BLOCK_STYLE_KEYS, BLOCK_STYLE_KEYS, GRID_COLOUR, } from "./liquid-glass-dark.js";
+export type { LiquidGlassBlockStyleKey, BlockStyleKey } from "./liquid-glass-dark.js";
+export declare function applyLiquidGlassCss(container: HTMLElement): () => void;

package/dist/themes/index.js

@@ -0,0 +1,12 @@
+import "./liquid-glass.css";
+export { liquidGlassDarkTheme, LIQUID_GLASS_DARK_THEME_NAME, LIQUID_GLASS_BLOCK_STYLE_KEYS, BLOCK_STYLE_KEYS, GRID_COLOUR, } from "./liquid-glass-dark.js";
+const BLOCKS_EDITOR_CLASS = "blocks-editor";
+const BLOCKS_EDITOR_LIQUID_GLASS_MOD = "blocks-editor--liquid-glass-dark";
+export function applyLiquidGlassCss(container) {
+    container.classList.add(BLOCKS_EDITOR_CLASS);
+    container.classList.add(BLOCKS_EDITOR_LIQUID_GLASS_MOD);
+    return () => {
+        container.classList.remove(BLOCKS_EDITOR_CLASS);
+        container.classList.remove(BLOCKS_EDITOR_LIQUID_GLASS_MOD);
+    };
+}