@world-engines/blocks-editor 0.1.0

package/dist/themes/liquid-glass-dark.d.ts

@@ -0,0 +1,57 @@
+import { Theme } from "blockly";
+export declare const BLOCK_CATEGORY_PALETTE: {
+    readonly events: {
+        readonly primary: "#16c784";
+        readonly secondary: "#45d5a0";
+        readonly tertiary: "#109463";
+    };
+    readonly control: {
+        readonly primary: "#ff9f43";
+        readonly secondary: "#ffb76e";
+        readonly tertiary: "#c97831";
+    };
+    readonly sensing: {
+        readonly primary: "#20c4d9";
+        readonly secondary: "#55d2e1";
+        readonly tertiary: "#1894a4";
+    };
+    readonly operators: {
+        readonly primary: "#a970ff";
+        readonly secondary: "#bd91ff";
+        readonly tertiary: "#7d54bf";
+    };
+    readonly variables: {
+        readonly primary: "#f4c542";
+        readonly secondary: "#f7d36e";
+        readonly tertiary: "#b99431";
+    };
+    readonly sdkInterfaces: {
+        readonly primary: "#ff6680";
+        readonly secondary: "#ff8da0";
+        readonly tertiary: "#bf4d60";
+    };
+    readonly viewInterfaces: {
+        readonly primary: "#4c8dff";
+        readonly secondary: "#76a8ff";
+        readonly tertiary: "#396abf";
+    };
+};
+export declare const BLOCK_STYLE_KEYS: {
+    readonly boolean: "boolean_blocks";
+    readonly dataEvent: "data_event_blocks";
+    readonly dataAttr: "data_attr_blocks";
+    readonly time: "time_blocks";
+    readonly container: "container_blocks";
+    readonly control: "control_blocks";
+    readonly sensing: "sensing_blocks";
+    readonly operators: "operators_blocks";
+    readonly variables: "variables_blocks";
+    readonly myBlocks: "my_blocks_blocks";
+    readonly scenarioHat: "scenario_hat_blocks";
+};
+export type BlockStyleKey = (typeof BLOCK_STYLE_KEYS)[keyof typeof BLOCK_STYLE_KEYS];
+export declare const GRID_COLOUR: "rgba(0, 200, 83, 0.14)";
+export declare const liquidGlassDarkTheme: Theme;
+export declare const LIQUID_GLASS_DARK_THEME_NAME: "liquid-glass-dark";
+export declare const LIQUID_GLASS_BLOCK_STYLE_KEYS: readonly ["boolean_blocks", "data_event_blocks", "data_attr_blocks", "time_blocks", "container_blocks", "control_blocks", "sensing_blocks", "operators_blocks", "variables_blocks", "my_blocks_blocks", "scenario_hat_blocks"];
+export type LiquidGlassBlockStyleKey = (typeof LIQUID_GLASS_BLOCK_STYLE_KEYS)[number];

package/dist/themes/liquid-glass-dark.js

@@ -0,0 +1,187 @@
+import { Theme, Themes } from "blockly";
+export const BLOCK_CATEGORY_PALETTE = {
+    events: { primary: "#16c784", secondary: "#45d5a0", tertiary: "#109463" },
+    control: { primary: "#ff9f43", secondary: "#ffb76e", tertiary: "#c97831" },
+    sensing: { primary: "#20c4d9", secondary: "#55d2e1", tertiary: "#1894a4" },
+    operators: { primary: "#a970ff", secondary: "#bd91ff", tertiary: "#7d54bf" },
+    variables: { primary: "#f4c542", secondary: "#f7d36e", tertiary: "#b99431" },
+    sdkInterfaces: { primary: "#ff6680", secondary: "#ff8da0", tertiary: "#bf4d60" },
+    viewInterfaces: { primary: "#4c8dff", secondary: "#76a8ff", tertiary: "#396abf" }
+};
+const COLOUR = {
+    booleanPrimary: "#00b8d4",
+    booleanSecondary: "#33c8de",
+    booleanTertiary: "#008fa3",
+    dataEventPrimary: "#00c853",
+    dataEventSecondary: "#33d475",
+    dataEventTertiary: "#009c40",
+    dataAttrPrimary: "#0bd48c",
+    dataAttrSecondary: "#3ddba4",
+    dataAttrTertiary: "#08a56d",
+    timePrimary: "#00e676",
+    timeSecondary: "#33eb91",
+    timeTertiary: "#00b25c",
+    containerPrimary: "#00a86b",
+    containerSecondary: "#33bd8a",
+    containerTertiary: "#008551",
+    controlPrimary: BLOCK_CATEGORY_PALETTE.control.primary,
+    controlSecondary: BLOCK_CATEGORY_PALETTE.control.secondary,
+    controlTertiary: BLOCK_CATEGORY_PALETTE.control.tertiary,
+    sensingPrimary: BLOCK_CATEGORY_PALETTE.sensing.primary,
+    sensingSecondary: BLOCK_CATEGORY_PALETTE.sensing.secondary,
+    sensingTertiary: BLOCK_CATEGORY_PALETTE.sensing.tertiary,
+    operatorsPrimary: BLOCK_CATEGORY_PALETTE.operators.primary,
+    operatorsSecondary: BLOCK_CATEGORY_PALETTE.operators.secondary,
+    operatorsTertiary: BLOCK_CATEGORY_PALETTE.operators.tertiary,
+    variablesPrimary: BLOCK_CATEGORY_PALETTE.variables.primary,
+    variablesSecondary: BLOCK_CATEGORY_PALETTE.variables.secondary,
+    variablesTertiary: BLOCK_CATEGORY_PALETTE.variables.tertiary,
+    myBlocksPrimary: "#00a8ff",
+    myBlocksSecondary: "#33baff",
+    myBlocksTertiary: "#0084cc",
+    scenarioHatPrimary: BLOCK_CATEGORY_PALETTE.events.primary,
+    scenarioHatSecondary: BLOCK_CATEGORY_PALETTE.events.secondary,
+    scenarioHatTertiary: BLOCK_CATEGORY_PALETTE.events.tertiary,
+    categoryControl: BLOCK_CATEGORY_PALETTE.control.primary,
+    categoryOperators: BLOCK_CATEGORY_PALETTE.operators.primary,
+    categoryVariables: BLOCK_CATEGORY_PALETTE.variables.primary,
+    categoryMotions: "#00a8ff",
+    categoryEvents: BLOCK_CATEGORY_PALETTE.events.primary,
+    categorySensing: BLOCK_CATEGORY_PALETTE.sensing.primary,
+    categoryMyBlocks: "#00a8ff"
+};
+const HAT = "";
+const HAT_CAP = "cap";
+export const BLOCK_STYLE_KEYS = {
+    boolean: "boolean_blocks",
+    dataEvent: "data_event_blocks",
+    dataAttr: "data_attr_blocks",
+    time: "time_blocks",
+    container: "container_blocks",
+    control: "control_blocks",
+    sensing: "sensing_blocks",
+    operators: "operators_blocks",
+    variables: "variables_blocks",
+    myBlocks: "my_blocks_blocks",
+    scenarioHat: "scenario_hat_blocks"
+};
+export const GRID_COLOUR = "rgba(0, 200, 83, 0.14)";
+export const liquidGlassDarkTheme = Theme.defineTheme("liquid-glass-dark", {
+    name: "liquid-glass-dark",
+    base: Themes.Zelos,
+    blockStyles: {
+        [BLOCK_STYLE_KEYS.boolean]: {
+            colourPrimary: COLOUR.booleanPrimary,
+            colourSecondary: COLOUR.booleanSecondary,
+            colourTertiary: COLOUR.booleanTertiary,
+            hat: HAT
+        },
+        [BLOCK_STYLE_KEYS.dataEvent]: {
+            colourPrimary: COLOUR.dataEventPrimary,
+            colourSecondary: COLOUR.dataEventSecondary,
+            colourTertiary: COLOUR.dataEventTertiary,
+            hat: HAT
+        },
+        [BLOCK_STYLE_KEYS.dataAttr]: {
+            colourPrimary: COLOUR.dataAttrPrimary,
+            colourSecondary: COLOUR.dataAttrSecondary,
+            colourTertiary: COLOUR.dataAttrTertiary,
+            hat: HAT
+        },
+        [BLOCK_STYLE_KEYS.time]: {
+            colourPrimary: COLOUR.timePrimary,
+            colourSecondary: COLOUR.timeSecondary,
+            colourTertiary: COLOUR.timeTertiary,
+            hat: HAT
+        },
+        [BLOCK_STYLE_KEYS.container]: {
+            colourPrimary: COLOUR.containerPrimary,
+            colourSecondary: COLOUR.containerSecondary,
+            colourTertiary: COLOUR.containerTertiary,
+            hat: HAT
+        },
+        [BLOCK_STYLE_KEYS.control]: {
+            colourPrimary: COLOUR.controlPrimary,
+            colourSecondary: COLOUR.controlSecondary,
+            colourTertiary: COLOUR.controlTertiary,
+            hat: HAT
+        },
+        [BLOCK_STYLE_KEYS.sensing]: {
+            colourPrimary: COLOUR.sensingPrimary,
+            colourSecondary: COLOUR.sensingSecondary,
+            colourTertiary: COLOUR.sensingTertiary,
+            hat: HAT
+        },
+        [BLOCK_STYLE_KEYS.operators]: {
+            colourPrimary: COLOUR.operatorsPrimary,
+            colourSecondary: COLOUR.operatorsSecondary,
+            colourTertiary: COLOUR.operatorsTertiary,
+            hat: HAT
+        },
+        [BLOCK_STYLE_KEYS.variables]: {
+            colourPrimary: COLOUR.variablesPrimary,
+            colourSecondary: COLOUR.variablesSecondary,
+            colourTertiary: COLOUR.variablesTertiary,
+            hat: HAT
+        },
+        [BLOCK_STYLE_KEYS.myBlocks]: {
+            colourPrimary: COLOUR.myBlocksPrimary,
+            colourSecondary: COLOUR.myBlocksSecondary,
+            colourTertiary: COLOUR.myBlocksTertiary,
+            hat: HAT
+        },
+        [BLOCK_STYLE_KEYS.scenarioHat]: {
+            colourPrimary: COLOUR.scenarioHatPrimary,
+            colourSecondary: COLOUR.scenarioHatSecondary,
+            colourTertiary: COLOUR.scenarioHatTertiary,
+            hat: HAT_CAP
+        }
+    },
+    categoryStyles: {
+        control_category: { colour: COLOUR.categoryControl },
+        operators_category: { colour: COLOUR.categoryOperators },
+        variables_category: { colour: COLOUR.categoryVariables },
+        motions_category: { colour: COLOUR.categoryMotions },
+        events_category: { colour: COLOUR.categoryEvents },
+        sensing_category: { colour: COLOUR.categorySensing },
+        my_blocks_category: { colour: COLOUR.categoryMyBlocks },
+        sdk_interfaces_category: { colour: BLOCK_CATEGORY_PALETTE.sdkInterfaces.primary },
+        view_interfaces_category: { colour: BLOCK_CATEGORY_PALETTE.viewInterfaces.primary }
+    },
+    componentStyles: {
+        workspaceBackgroundColour: "transparent",
+        toolboxBackgroundColour: "rgba(6, 14, 10, 0.62)",
+        toolboxForegroundColour: "rgba(220, 246, 230, 0.9)",
+        flyoutBackgroundColour: "rgba(8, 16, 12, 0.66)",
+        flyoutForegroundColour: "rgba(220, 246, 230, 0.9)",
+        flyoutOpacity: 1,
+        scrollbarColour: "rgba(0, 200, 83, 0.32)",
+        scrollbarOpacity: 0.8,
+        insertionMarkerColour: "#00e676",
+        insertionMarkerOpacity: 0.5,
+        markerColour: "#00c853",
+        cursorColour: "#00c853",
+        selectedGlowColour: "#00e676",
+        selectedGlowOpacity: 0.55
+    },
+    fontStyle: {
+        family: "'Inter', 'PingFang SC', 'Hiragino Sans GB', 'Microsoft YaHei', system-ui, sans-serif",
+        weight: "500",
+        size: 12
+    },
+    startHats: false
+});
+export const LIQUID_GLASS_DARK_THEME_NAME = "liquid-glass-dark";
+export const LIQUID_GLASS_BLOCK_STYLE_KEYS = [
+    BLOCK_STYLE_KEYS.boolean,
+    BLOCK_STYLE_KEYS.dataEvent,
+    BLOCK_STYLE_KEYS.dataAttr,
+    BLOCK_STYLE_KEYS.time,
+    BLOCK_STYLE_KEYS.container,
+    BLOCK_STYLE_KEYS.control,
+    BLOCK_STYLE_KEYS.sensing,
+    BLOCK_STYLE_KEYS.operators,
+    BLOCK_STYLE_KEYS.variables,
+    BLOCK_STYLE_KEYS.myBlocks,
+    BLOCK_STYLE_KEYS.scenarioHat
+];

package/dist/themes/liquid-glass.css

@@ -0,0 +1,195 @@
+.blocks-editor__blockly-host {
+  position: relative;
+  width: 100%;
+  height: 100%;
+}
+
+.blocks-editor {
+  position: relative;
+  width: 100%;
+  height: 100%;
+  border: 1px solid rgba(0, 200, 83, 0.24);
+  border-radius: 0.5rem;
+  background: linear-gradient(
+      135deg,
+      rgba(4, 10, 8, 0.82) 0%,
+      rgba(8, 18, 14, 0.76) 100%
+    );
+  background-clip: padding-box;
+  box-shadow:
+    0 1.25rem 2.5rem rgba(0, 0, 0, 0.55),
+    inset 0 1px 0 rgba(0, 230, 118, 0.08);
+  backdrop-filter: blur(8px) saturate(140%);
+  -webkit-backdrop-filter: blur(8px) saturate(140%);
+  overflow: hidden;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyMainBackground {
+  fill: transparent;
+  stroke: none;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyToolboxDiv {
+  border-inline-end: 1px solid rgba(0, 200, 83, 0.22);
+  background: linear-gradient(
+    180deg,
+    rgba(4, 10, 8, 0.78) 0%,
+    rgba(4, 12, 8, 0.72) 100%
+  );
+  backdrop-filter: blur(10px) saturate(140%);
+  -webkit-backdrop-filter: blur(10px) saturate(140%);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyFlyout {
+  background: rgba(8, 16, 12, 0.62);
+  backdrop-filter: blur(12px) saturate(140%);
+  -webkit-backdrop-filter: blur(12px) saturate(140%);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyFlyoutBackground {
+  fill: rgba(8, 16, 12, 0.62);
+  fill-opacity: 1;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyTreeRow {
+  border-radius: 0.5rem;
+  margin: 0.125rem 0.375rem;
+  min-height: 2.25rem;
+  padding-block: 0.5rem;
+  color: rgba(220, 246, 230, 0.86);
+  transition: background-color 160ms ease, color 160ms ease;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyTreeRow:hover {
+  background: rgba(0, 230, 118, 0.14);
+  color: rgba(240, 255, 245, 0.96);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyTreeSelected {
+  background: rgba(0, 200, 83, 0.22);
+  color: rgba(240, 255, 245, 0.98);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyTreeLabel {
+  color: inherit;
+  font-weight: 500;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyDraggable .blocklyPath {
+  filter: drop-shadow(0 0.5rem 1rem rgba(0, 0, 0, 0.45));
+}
+
+.blocks-editor--liquid-glass-dark .blocklyText {
+  fill: rgba(240, 255, 245, 0.96);
+  font-weight: 500;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyEditableText > rect {
+  fill: rgba(4, 12, 8, 0.6);
+  stroke: rgba(0, 230, 118, 0.32);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyHtmlInput {
+  color: rgba(240, 255, 245, 0.96);
+  background: rgba(4, 12, 8, 0.85);
+  border: 1px solid rgba(0, 230, 118, 0.36);
+  border-radius: 0.375rem;
+  caret-color: hsl(140, 100%, 55%);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyHtmlInput::placeholder {
+  color: rgba(170, 200, 180, 0.55);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyDropdownText {
+  fill: rgba(240, 255, 245, 0.96);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyWidgetDiv .goog-menu,
+.blocks-editor--liquid-glass-dark .blocklyDropDownDiv {
+  background: rgba(4, 12, 8, 0.94);
+  border: 1px solid rgba(0, 230, 118, 0.32);
+  border-radius: 0.5rem;
+  box-shadow: 0 1rem 2rem rgba(0, 0, 0, 0.6);
+  backdrop-filter: blur(12px) saturate(140%);
+  -webkit-backdrop-filter: blur(12px) saturate(140%);
+  color: rgba(220, 246, 230, 0.94);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyDropDownContent {
+  color: inherit;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyMenuItem {
+  color: rgba(220, 246, 230, 0.94);
+  border-radius: 0.375rem;
+  padding-inline: 0.625rem;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyMenuItemHighlight,
+.blocks-editor--liquid-glass-dark .blocklyMenuItem:hover {
+  background: rgba(0, 230, 118, 0.18);
+  color: rgba(240, 255, 245, 0.98);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyScrollbarHandle {
+  fill: rgba(0, 200, 83, 0.4);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyScrollbarVertical,
+.blocks-editor--liquid-glass-dark .blocklyScrollbarVertical .blocklyScrollbarHandle {
+  width: 3px !important;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyScrollbarHorizontal,
+.blocks-editor--liquid-glass-dark .blocklyScrollbarHorizontal .blocklyScrollbarHandle {
+  height: 3px !important;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyTrash,
+.blocks-editor--liquid-glass-dark .blocklyZoom {
+  display: none !important;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyScrollbarHandle:hover,
+.blocks-editor--liquid-glass-dark .blocklyScrollbarHandle.blocklyScrollbarHovered {
+  fill: rgba(0, 230, 118, 0.6);
+}
+
+.blocks-editor--liquid-glass-dark ::-webkit-scrollbar {
+  width: 3px;
+  height: 3px;
+}
+
+.blocks-editor--liquid-glass-dark ::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.blocks-editor--liquid-glass-dark ::-webkit-scrollbar-thumb {
+  background: rgba(0, 200, 83, 0.36);
+  border-radius: 999px;
+}
+
+.blocks-editor--liquid-glass-dark ::-webkit-scrollbar-thumb:hover {
+  background: rgba(0, 230, 118, 0.56);
+}
+
+.blocks-editor--liquid-glass-dark .blocklyTrash > image,
+.blocks-editor--liquid-glass-dark .blocklyTrash > rect {
+  opacity: 0.78;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyZoom > image,
+.blocks-editor--liquid-glass-dark .blocklyZoom > rect {
+  opacity: 0.78;
+}
+
+.blocks-editor--liquid-glass-dark .blocklyContextMenu {
+  background: rgba(4, 12, 8, 0.94);
+  border: 1px solid rgba(0, 230, 118, 0.32);
+  border-radius: 0.5rem;
+  box-shadow: 0 1rem 2rem rgba(0, 0, 0, 0.6);
+  backdrop-filter: blur(10px);
+  -webkit-backdrop-filter: blur(10px);
+  color: rgba(220, 246, 230, 0.94);
+}

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

@@ -0,0 +1,10 @@
+import type { ViewExposureFunction } from "@world-engines/view-exposure";
+export interface ViewBlockCatalog {
+    readonly manifestHash: string;
+    readonly manifestRevision: number;
+    readonly functions: ReadonlyArray<ViewExposureFunction>;
+}
+export declare const viewBlockType: (fn: ViewExposureFunction, hash: string) => string;
+/** 只注册当前 manifest revision；旧 block 不创建 tombstone。 */
+export declare const registerViewBlocks: (catalog: ViewBlockCatalog) => ReadonlyArray<string>;
+export declare const isViewActionBlockType: (type: string) => boolean;

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

@@ -0,0 +1,67 @@
+import * as Blockly from "blockly";
+const VIEW_BLOCK_PREFIX = "view_action_";
+const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+const MANIFEST_HASH = /^[A-Za-z0-9][A-Za-z0-9:._-]{0,127}$/;
+const registered = new Set();
+const manifestFingerprint = (hash) => hash.replace(/[^A-Za-z0-9]/g, "").slice(-16);
+export const viewBlockType = (fn, hash) => `${VIEW_BLOCK_PREFIX}${fn.name}_${manifestFingerprint(hash)}`;
+const blocklyCheckForSchema = (schema) => {
+    switch (schema.type) {
+        case "string": return "String";
+        case "number":
+        case "integer": return "Number";
+        case "boolean": return "Boolean";
+        case "array":
+        case "object": return undefined;
+    }
+};
+const authorizedTriggerFunctions = (catalog) => {
+    if (!MANIFEST_HASH.test(catalog.manifestHash)
+        || manifestFingerprint(catalog.manifestHash).length === 0) {
+        throw new Error("view_action_catalog_manifest_hash_invalid");
+    }
+    if (!Number.isSafeInteger(catalog.manifestRevision) || catalog.manifestRevision < 0) {
+        throw new Error("view_action_catalog_manifest_revision_invalid");
+    }
+    const functions = catalog.functions.filter((fn) => fn.target === "trigger" || fn.target === "both");
+    const ids = new Set();
+    const names = new Set();
+    const blockTypes = new Set();
+    for (const fn of functions) {
+        if (!IDENTIFIER.test(fn.name))
+            throw new Error(`view_action_name_invalid:${fn.name}`);
+        if (ids.has(fn.id))
+            throw new Error(`view_action_exposure_id_duplicate:${fn.id}`);
+        if (names.has(fn.name))
+            throw new Error(`view_action_name_duplicate:${fn.name}`);
+        const type = viewBlockType(fn, catalog.manifestHash);
+        if (blockTypes.has(type))
+            throw new Error(`view_action_block_type_collision:${type}`);
+        ids.add(fn.id);
+        names.add(fn.name);
+        blockTypes.add(type);
+    }
+    return functions;
+};
+/** 只注册当前 manifest revision；旧 block 不创建 tombstone。 */
+export const registerViewBlocks = (catalog) => authorizedTriggerFunctions(catalog).map((fn) => {
+    const type = viewBlockType(fn, catalog.manifestHash);
+    if (!registered.has(type)) {
+        const args0 = Object.entries(fn.parameters.properties).map(([name, schema]) => {
+            const check = blocklyCheckForSchema(schema);
+            return { type: "input_value", name, ...(check === undefined ? {} : { check }) };
+        });
+        Blockly.common.defineBlocksWithJsonArray([{
+                type,
+                message0: `${fn.label}${args0.map((_, index) => ` %${index + 1}`).join("")}`,
+                args0,
+                previousStatement: null,
+                nextStatement: null,
+                colour: "#4c8dff",
+                tooltip: fn.description
+            }]);
+        registered.add(type);
+    }
+    return type;
+});
+export const isViewActionBlockType = (type) => type.startsWith(VIEW_BLOCK_PREFIX);

package/dist/workspace.d.ts

@@ -0,0 +1,33 @@
+import * as Blockly from "blockly";
+import { type CtxEdge, type CtxEntity, type CtxEvent, type CtxVariable } from "./blocks/ctx.js";
+import type { WorldTimeBounds } from "./blocks/time-fields.js";
+import { CATEGORY_IDS, type CategoryId } from "./blocks/toolbox.js";
+import type { SdkCatalog } from "./sdk-to-block/signature.js";
+import { type ViewBlockCatalog } from "./view-to-block/index.js";
+export type BlocksWorkspaceSchema = "trigger-definition" | "trigger" | "tmw-condition-v3";
+export interface BlocksWorkspaceTriggerCtx {
+    readonly event_list: ReadonlyArray<CtxEvent>;
+    readonly entity_list: ReadonlyArray<CtxEntity>;
+    readonly edge_list?: ReadonlyArray<CtxEdge>;
+    readonly variable_list?: ReadonlyArray<CtxVariable>;
+    readonly sdk_catalog?: SdkCatalog;
+    readonly worldTime?: WorldTimeBounds;
+    readonly view_catalog?: ViewBlockCatalog;
+}
+export interface BlocksWorkspaceHandle {
+    selectCategory(id: CategoryId): void;
+    getWorkspace(): Blockly.WorkspaceSvg | null;
+}
+export interface BlocksWorkspaceProps {
+    readonly schema: BlocksWorkspaceSchema;
+    readonly ownerKey: string;
+    /** Blockly serialization.workspaces.save 后 JSON.stringify 的产物 空 workspace 传 "" 或 `{"blocks":{"blocks":[]}}` */
+    readonly workspaceJson: string;
+    readonly ctx: BlocksWorkspaceTriggerCtx;
+    readonly onWorkspaceJsonChange: (nextJson: string) => void;
+    readonly className?: string;
+    readonly mediaBaseUrl?: string;
+}
+export declare const BlocksWorkspace: import("react").ForwardRefExoticComponent<BlocksWorkspaceProps & import("react").RefAttributes<BlocksWorkspaceHandle>>;
+export { CATEGORY_IDS };
+export type { CategoryId };