@world-engines/blocks-editor 0.1.0

package/dist/blocks/time-fields.d.ts

@@ -0,0 +1,16 @@
+export interface WorldTimeBounds {
+    readonly months_per_year: number;
+    readonly days_per_month: number;
+    readonly hours_per_day: number;
+    readonly minutes_per_hour: number;
+    readonly seconds_per_minute: number;
+}
+export type WorldTimePointKey = "year" | "month" | "day" | "hour" | "minute" | "second";
+export interface TimeFieldSpec {
+    readonly key: WorldTimePointKey;
+    readonly labelKey: string;
+    readonly lo: (cfg: WorldTimeBounds) => number;
+    readonly hi: (cfg: WorldTimeBounds) => number;
+}
+export declare const DEFAULT_WORLD_TIME_BOUNDS: WorldTimeBounds;
+export declare const TIME_FIELDS: ReadonlyArray<TimeFieldSpec>;

package/dist/blocks/time-fields.js

@@ -0,0 +1,45 @@
+export const DEFAULT_WORLD_TIME_BOUNDS = {
+    months_per_year: 12,
+    days_per_month: 30,
+    hours_per_day: 24,
+    minutes_per_hour: 60,
+    seconds_per_minute: 60
+};
+export const TIME_FIELDS = [
+    {
+        key: "year",
+        labelKey: "editor.world_time.year",
+        lo: () => 0,
+        hi: () => Number.MAX_SAFE_INTEGER
+    },
+    {
+        key: "month",
+        labelKey: "editor.world_time.month",
+        lo: () => 1,
+        hi: (cfg) => cfg.months_per_year
+    },
+    {
+        key: "day",
+        labelKey: "editor.world_time.day",
+        lo: () => 1,
+        hi: (cfg) => cfg.days_per_month
+    },
+    {
+        key: "hour",
+        labelKey: "editor.world_time.hour",
+        lo: () => 0,
+        hi: (cfg) => cfg.hours_per_day - 1
+    },
+    {
+        key: "minute",
+        labelKey: "editor.world_time.minute",
+        lo: () => 0,
+        hi: (cfg) => cfg.minutes_per_hour - 1
+    },
+    {
+        key: "second",
+        labelKey: "editor.world_time.second",
+        lo: () => 0,
+        hi: (cfg) => cfg.seconds_per_minute - 1
+    }
+];

package/dist/blocks/toolbox.d.ts

@@ -0,0 +1,53 @@
+export interface ToolboxBlockEntry {
+    readonly kind: "block";
+    readonly type: string;
+}
+export interface ToolboxLabelEntry {
+    readonly kind: "label";
+    readonly text: string;
+}
+export interface ToolboxSepEntry {
+    readonly kind: "sep";
+    readonly gap?: number;
+}
+export type ToolboxCategoryContent = ToolboxBlockEntry | ToolboxLabelEntry | ToolboxSepEntry;
+export interface ToolboxCategoryEntry {
+    readonly kind: "category";
+    readonly name: string;
+    readonly categorystyle: string;
+    readonly contents: ReadonlyArray<ToolboxCategoryContent>;
+    readonly disabled?: boolean;
+}
+export interface ToolboxJson {
+    readonly kind: "categoryToolbox";
+    readonly contents: ReadonlyArray<ToolboxCategoryEntry>;
+}
+export declare const CATEGORY_IDS: {
+    readonly events: "events";
+    readonly control: "control";
+    readonly sensing: "sensing";
+    readonly operators: "operators";
+    readonly variables: "variables";
+    readonly sdkInterfaces: "sdk_interfaces";
+    readonly viewInterfaces: "view_interfaces";
+};
+export type CategoryId = (typeof CATEGORY_IDS)[keyof typeof CATEGORY_IDS];
+export declare const CATEGORY_STYLE_KEYS: {
+    readonly events: "events_category";
+    readonly control: "control_category";
+    readonly sensing: "sensing_category";
+    readonly operators: "operators_category";
+    readonly variables: "variables_category";
+    readonly sdk_interfaces: "sdk_interfaces_category";
+    readonly view_interfaces: "view_interfaces_category";
+};
+export interface ToolboxBuildOptions {
+    readonly schema?: "trigger-definition" | "trigger";
+    readonly sdkBlockTypes?: ReadonlyArray<string>;
+    readonly viewBlockTypes?: ReadonlyArray<string>;
+}
+export declare function buildToolbox(options?: ToolboxBuildOptions): ToolboxJson;
+export declare function getToolbox(): ToolboxJson;
+export declare function listToolboxCategoryNames(): ReadonlyArray<string>;
+export declare function listToolboxCategoryIds(): ReadonlyArray<CategoryId>;
+export declare function categoryDisplayNameOf(id: CategoryId): string;

package/dist/blocks/toolbox.js

@@ -0,0 +1,195 @@
+import { BLOCK_TYPES } from "./registry.js";
+export const CATEGORY_IDS = {
+    events: "events",
+    control: "control",
+    sensing: "sensing",
+    operators: "operators",
+    variables: "variables",
+    sdkInterfaces: "sdk_interfaces",
+    viewInterfaces: "view_interfaces"
+};
+export const CATEGORY_STYLE_KEYS = {
+    [CATEGORY_IDS.events]: "events_category",
+    [CATEGORY_IDS.control]: "control_category",
+    [CATEGORY_IDS.sensing]: "sensing_category",
+    [CATEGORY_IDS.operators]: "operators_category",
+    [CATEGORY_IDS.variables]: "variables_category",
+    [CATEGORY_IDS.sdkInterfaces]: "sdk_interfaces_category",
+    [CATEGORY_IDS.viewInterfaces]: "view_interfaces_category"
+};
+const GROUP_SEP_GAP = 6;
+const block = (type) => ({ kind: "block", type });
+const groupLabel = (text) => ({ kind: "label", text });
+const sep = () => ({ kind: "sep", gap: GROUP_SEP_GAP });
+const TRIGGER_DEFINITION_CONTENTS = [
+    groupLabel("定义"),
+    block(BLOCK_TYPES.triggerRoot),
+    sep(),
+    groupLabel("组合条件"),
+    block(BLOCK_TYPES.opAnd),
+    block(BLOCK_TYPES.opOr),
+    block(BLOCK_TYPES.opNot),
+    sep(),
+    groupLabel("可执行条件"),
+    block(BLOCK_TYPES.leafTime),
+    block(BLOCK_TYPES.leafEvent),
+    block(BLOCK_TYPES.leafNl),
+    block(BLOCK_TYPES.leafDaySegment)
+];
+const GLOBAL_CATEGORIES = [
+    {
+        kind: "category",
+        name: "事件",
+        categorystyle: CATEGORY_STYLE_KEYS.events,
+        contents: [
+            block("when_scenario_start"),
+            block("when_value_changed"),
+            block("when_time_changed"),
+            block("when_entity_state_changed"),
+            block("when_var_changed"),
+            block("when_time_reached"),
+            block("when_recall_success")
+        ]
+    },
+    {
+        kind: "category",
+        name: "控制",
+        categorystyle: CATEGORY_STYLE_KEYS.control,
+        contents: [
+            block("if"),
+            block("if_else"),
+            block("repeat"),
+            block("repeat_until"),
+            block("wait_seconds"),
+            block("stop_this_script")
+        ]
+    },
+    {
+        kind: "category",
+        name: "侦测",
+        categorystyle: CATEGORY_STYLE_KEYS.sensing,
+        contents: [
+            block("sense_time_year"),
+            block("sense_time_month"),
+            block("sense_time_day"),
+            block("sense_time_hour"),
+            block("sense_time_minute"),
+            block("sense_time_second"),
+            block("sense_object_state"),
+            block("sense_object_attr"),
+            block("sense_edge_relation"),
+            block("sense_relation_ref"),
+            block("sense_object_frozen")
+        ]
+    },
+    {
+        kind: "category",
+        name: "运算",
+        categorystyle: CATEGORY_STYLE_KEYS.operators,
+        contents: [
+            block("op_time_crossed"),
+            block("op_and"),
+            block("op_or"),
+            block("op_not"),
+            block("op_equals"),
+            block("op_greater"),
+            block("op_less"),
+            block("op_contains"),
+            block("op_add"),
+            block("op_subtract"),
+            block("op_multiply"),
+            block("op_divide"),
+            block("op_mod"),
+            block("op_round"),
+            block("op_abs"),
+            block("op_join"),
+            block("op_letter_of"),
+            block("op_length_of")
+        ]
+    },
+    {
+        kind: "category",
+        name: "变量与世界",
+        categorystyle: CATEGORY_STYLE_KEYS.variables,
+        contents: [
+            block("var_read"),
+            block("var_set"),
+            block("var_change"),
+            block("var_const_boolean"),
+            block("var_const_value"),
+            block("var_const_time"),
+            sep(),
+            block("entity_freeze"),
+            block("entity_toggle"),
+            block("entity_enable"),
+            block("entity_disable"),
+            block("attr_set"),
+            block("time_advance"),
+            block("time_set")
+        ]
+    }
+];
+const DYNAMIC_CATEGORY_NAMES = {
+    [CATEGORY_IDS.sdkInterfaces]: "SDK 接口",
+    [CATEGORY_IDS.viewInterfaces]: "视图操作"
+};
+const dynamicCategory = (id, blockTypes) => {
+    if (blockTypes.length === 0)
+        return null;
+    const unique = new Set(blockTypes);
+    if (unique.size !== blockTypes.length) {
+        throw new Error(`toolbox_dynamic_block_type_duplicate:${id}`);
+    }
+    return {
+        kind: "category",
+        name: DYNAMIC_CATEGORY_NAMES[id],
+        categorystyle: CATEGORY_STYLE_KEYS[id],
+        contents: blockTypes.map(block)
+    };
+};
+export function buildToolbox(options = {}) {
+    if (options.schema === "trigger") {
+        const sdkCategory = dynamicCategory(CATEGORY_IDS.sdkInterfaces, options.sdkBlockTypes ?? []);
+        const viewCategory = dynamicCategory(CATEGORY_IDS.viewInterfaces, options.viewBlockTypes ?? []);
+        return {
+            kind: "categoryToolbox",
+            contents: [
+                ...GLOBAL_CATEGORIES,
+                ...(sdkCategory === null ? [] : [sdkCategory]),
+                ...(viewCategory === null ? [] : [viewCategory])
+            ]
+        };
+    }
+    return {
+        kind: "categoryToolbox",
+        contents: [{
+                kind: "category",
+                name: "◇  触发器条件",
+                categorystyle: CATEGORY_STYLE_KEYS.events,
+                contents: TRIGGER_DEFINITION_CONTENTS
+            }]
+    };
+}
+const DEFAULT_TOOLBOX = buildToolbox();
+export function getToolbox() {
+    return DEFAULT_TOOLBOX;
+}
+export function listToolboxCategoryNames() {
+    return GLOBAL_CATEGORIES.map((category) => category.name);
+}
+export function listToolboxCategoryIds() {
+    return [
+        CATEGORY_IDS.events,
+        CATEGORY_IDS.control,
+        CATEGORY_IDS.sensing,
+        CATEGORY_IDS.operators,
+        CATEGORY_IDS.variables
+    ];
+}
+export function categoryDisplayNameOf(id) {
+    if (id === CATEGORY_IDS.sdkInterfaces || id === CATEGORY_IDS.viewInterfaces) {
+        return DYNAMIC_CATEGORY_NAMES[id];
+    }
+    const index = listToolboxCategoryIds().indexOf(id);
+    return index >= 0 ? GLOBAL_CATEGORIES[index]?.name ?? id : id;
+}

package/dist/fields/AttrPickerField.d.ts

@@ -0,0 +1,13 @@
+import * as Blockly from "blockly";
+export interface AttrPickerFieldOptions extends Blockly.FieldConfig {
+    readonly value?: string;
+    readonly entityFieldName?: string;
+}
+export declare class AttrPickerField extends Blockly.Field<string> {
+    private entityFieldName_;
+    constructor(value?: string, entityFieldName?: string);
+    static fromJson(options: Blockly.FieldConfig): AttrPickerField;
+    private readEntityId;
+    protected showEditor_(): void;
+    protected getText_(): string | null;
+}

package/dist/fields/AttrPickerField.js

@@ -0,0 +1,48 @@
+import * as Blockly from "blockly";
+import { findAttrLabel, readCtxFromWorkspace } from "../blocks/ctx.js";
+import { dispatchPickerRequest, toAttrCandidates } from "./picker-events.js";
+const PLACEHOLDER_LABEL = "(选择对象)";
+const PICKER_TITLE = "选择对象";
+const ENTITY_FIELD_NAME_DEFAULT = "ENTITY";
+export class AttrPickerField extends Blockly.Field {
+    entityFieldName_;
+    constructor(value = "", entityFieldName = ENTITY_FIELD_NAME_DEFAULT) {
+        super(value);
+        this.entityFieldName_ = entityFieldName;
+    }
+    static fromJson(options) {
+        const opts = options;
+        return new AttrPickerField(opts.value ?? "", opts.entityFieldName ?? ENTITY_FIELD_NAME_DEFAULT);
+    }
+    readEntityId() {
+        const source = this.getSourceBlock();
+        if (!source)
+            return "";
+        const raw = source.getFieldValue(this.entityFieldName_);
+        return typeof raw === "string" ? raw : "";
+    }
+    showEditor_() {
+        const source = this.getSourceBlock();
+        if (!source)
+            return;
+        const ctx = readCtxFromWorkspace(source.workspace ?? null);
+        const entityId = this.readEntityId();
+        const candidates = toAttrCandidates(ctx, entityId);
+        dispatchPickerRequest({
+            kind: "attr",
+            title: PICKER_TITLE,
+            candidates,
+            currentValue: this.getValue() ?? "",
+            onSelect: (id) => this.setValue(id)
+        });
+    }
+    getText_() {
+        const source = this.getSourceBlock();
+        const ctx = readCtxFromWorkspace(source?.workspace ?? null);
+        const id = this.getValue();
+        if (id === null || id === undefined || id.length === 0)
+            return PLACEHOLDER_LABEL;
+        const entityId = this.readEntityId();
+        return findAttrLabel(ctx, entityId, id);
+    }
+}

package/dist/fields/EdgePickerField.d.ts

@@ -0,0 +1,10 @@
+import * as Blockly from "blockly";
+export interface EdgePickerFieldOptions extends Blockly.FieldConfig {
+    readonly value?: string;
+}
+export declare class EdgePickerField extends Blockly.Field<string> {
+    constructor(value?: string);
+    static fromJson(options: Blockly.FieldConfig): EdgePickerField;
+    protected showEditor_(): void;
+    protected getText_(): string | null;
+}

package/dist/fields/EdgePickerField.js

@@ -0,0 +1,36 @@
+import * as Blockly from "blockly";
+import { findEdgeLabel, readCtxFromWorkspace } from "../blocks/ctx.js";
+import { dispatchPickerRequest, toEdgeCandidates } from "./picker-events.js";
+const PLACEHOLDER_LABEL = "(选择对象)";
+const PICKER_TITLE = "选择对象";
+export class EdgePickerField extends Blockly.Field {
+    constructor(value = "") {
+        super(value);
+    }
+    static fromJson(options) {
+        const opts = options;
+        return new EdgePickerField(opts.value ?? "");
+    }
+    showEditor_() {
+        const source = this.getSourceBlock();
+        if (!source)
+            return;
+        const ctx = readCtxFromWorkspace(source.workspace ?? null);
+        const candidates = toEdgeCandidates(ctx);
+        dispatchPickerRequest({
+            kind: "edge",
+            title: PICKER_TITLE,
+            candidates,
+            currentValue: this.getValue() ?? "",
+            onSelect: (id) => this.setValue(id)
+        });
+    }
+    getText_() {
+        const source = this.getSourceBlock();
+        const ctx = readCtxFromWorkspace(source?.workspace ?? null);
+        const id = this.getValue();
+        if (id === null || id === undefined || id.length === 0)
+            return PLACEHOLDER_LABEL;
+        return findEdgeLabel(ctx, id);
+    }
+}

package/dist/fields/EntityPickerField.d.ts

@@ -0,0 +1,10 @@
+import * as Blockly from "blockly";
+export interface EntityPickerFieldOptions extends Blockly.FieldConfig {
+    readonly value?: string;
+}
+export declare class EntityPickerField extends Blockly.Field<string> {
+    constructor(value?: string);
+    static fromJson(options: Blockly.FieldConfig): EntityPickerField;
+    protected showEditor_(): void;
+    protected getText_(): string | null;
+}

package/dist/fields/EntityPickerField.js

@@ -0,0 +1,36 @@
+import * as Blockly from "blockly";
+import { findEntityName, readCtxFromWorkspace } from "../blocks/ctx.js";
+import { dispatchPickerRequest, toEntityCandidates } from "./picker-events.js";
+const PLACEHOLDER_LABEL = "(选择对象)";
+const PICKER_TITLE = "选择对象";
+export class EntityPickerField extends Blockly.Field {
+    constructor(value = "") {
+        super(value);
+    }
+    static fromJson(options) {
+        const opts = options;
+        return new EntityPickerField(opts.value ?? "");
+    }
+    showEditor_() {
+        const source = this.getSourceBlock();
+        if (!source)
+            return;
+        const ctx = readCtxFromWorkspace(source.workspace ?? null);
+        const candidates = toEntityCandidates(ctx);
+        dispatchPickerRequest({
+            kind: "entity",
+            title: PICKER_TITLE,
+            candidates,
+            currentValue: this.getValue() ?? "",
+            onSelect: (id) => this.setValue(id)
+        });
+    }
+    getText_() {
+        const source = this.getSourceBlock();
+        const ctx = readCtxFromWorkspace(source?.workspace ?? null);
+        const id = this.getValue();
+        if (id === null || id === undefined || id.length === 0)
+            return PLACEHOLDER_LABEL;
+        return findEntityName(ctx, id);
+    }
+}

package/dist/fields/StatePickerField.d.ts

@@ -0,0 +1,13 @@
+import * as Blockly from "blockly";
+export interface StatePickerFieldOptions extends Blockly.FieldConfig {
+    readonly value?: string;
+    readonly entityFieldName?: string;
+}
+export declare class StatePickerField extends Blockly.Field<string> {
+    private entityFieldName_;
+    constructor(value?: string, entityFieldName?: string);
+    static fromJson(options: Blockly.FieldConfig): StatePickerField;
+    private readEntityId;
+    protected showEditor_(): void;
+    protected getText_(): string | null;
+}

package/dist/fields/StatePickerField.js

@@ -0,0 +1,47 @@
+import * as Blockly from "blockly";
+import { findStateLabel, readCtxFromWorkspace } from "../blocks/ctx.js";
+import { dispatchPickerRequest, toStateCandidates } from "./picker-events.js";
+const PLACEHOLDER_LABEL = "(选择状态)";
+const ENTITY_FIELD_NAME_DEFAULT = "ENTITY";
+export class StatePickerField extends Blockly.Field {
+    entityFieldName_;
+    constructor(value = "", entityFieldName = ENTITY_FIELD_NAME_DEFAULT) {
+        super(value);
+        this.entityFieldName_ = entityFieldName;
+    }
+    static fromJson(options) {
+        const opts = options;
+        return new StatePickerField(opts.value ?? "", opts.entityFieldName ?? ENTITY_FIELD_NAME_DEFAULT);
+    }
+    readEntityId() {
+        const source = this.getSourceBlock();
+        if (!source)
+            return "";
+        const raw = source.getFieldValue(this.entityFieldName_);
+        return typeof raw === "string" ? raw : "";
+    }
+    showEditor_() {
+        const source = this.getSourceBlock();
+        if (!source)
+            return;
+        const ctx = readCtxFromWorkspace(source.workspace ?? null);
+        const entityId = this.readEntityId();
+        const candidates = toStateCandidates(ctx, entityId);
+        dispatchPickerRequest({
+            kind: "state",
+            title: "选择状态",
+            candidates,
+            currentValue: this.getValue() ?? "",
+            onSelect: (id) => this.setValue(id)
+        });
+    }
+    getText_() {
+        const source = this.getSourceBlock();
+        const ctx = readCtxFromWorkspace(source?.workspace ?? null);
+        const id = this.getValue();
+        if (id === null || id === undefined || id.length === 0)
+            return PLACEHOLDER_LABEL;
+        const entityId = this.readEntityId();
+        return findStateLabel(ctx, entityId, id);
+    }
+}

package/dist/fields/TimePickerField.d.ts

@@ -0,0 +1,10 @@
+import * as Blockly from "blockly";
+export interface TimePickerFieldOptions extends Blockly.FieldConfig {
+    readonly value?: string;
+}
+export declare class TimePickerField extends Blockly.Field<string> {
+    constructor(value?: string);
+    static fromJson(options: Blockly.FieldConfig): TimePickerField;
+    protected showEditor_(): void;
+    protected getText_(): string | null;
+}

package/dist/fields/TimePickerField.js

@@ -0,0 +1,81 @@
+import * as Blockly from "blockly";
+import { readCtxFromWorkspace } from "../blocks/ctx.js";
+import { DEFAULT_WORLD_TIME_BOUNDS, TIME_FIELDS } from "../blocks/time-fields.js";
+import { dispatchPickerRequest } from "./picker-events.js";
+const PLACEHOLDER_LABEL = "(选择时间)";
+const DEFAULT_TIME_PAYLOAD = {
+    year: 0,
+    month: 1,
+    day: 1,
+    hour: 0,
+    minute: 0,
+    second: 0
+};
+const parseTimePayload = (raw) => {
+    if (raw.length === 0)
+        return DEFAULT_TIME_PAYLOAD;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed !== null
+            && typeof parsed === "object"
+            && "year" in parsed
+            && "month" in parsed) {
+            const p = parsed;
+            return {
+                year: typeof p.year === "number" ? p.year : 0,
+                month: typeof p.month === "number" ? p.month : 1,
+                day: typeof p.day === "number" ? p.day : 1,
+                hour: typeof p.hour === "number" ? p.hour : 0,
+                minute: typeof p.minute === "number" ? p.minute : 0,
+                second: typeof p.second === "number" ? p.second : 0
+            };
+        }
+    }
+    catch {
+        // ignore parse error
+    }
+    return DEFAULT_TIME_PAYLOAD;
+};
+const formatTimeLabel = (p) => `${p.year}-${String(p.month).padStart(2, "0")}-${String(p.day).padStart(2, "0")} ${String(p.hour).padStart(2, "0")}:${String(p.minute).padStart(2, "0")}:${String(p.second).padStart(2, "0")}`;
+export class TimePickerField extends Blockly.Field {
+    constructor(value = "") {
+        super(value);
+    }
+    static fromJson(options) {
+        const opts = options;
+        return new TimePickerField(opts.value ?? "");
+    }
+    showEditor_() {
+        const source = this.getSourceBlock();
+        if (!source)
+            return;
+        const ctx = readCtxFromWorkspace(source.workspace ?? null);
+        const bounds = ctx.worldTime ?? DEFAULT_WORLD_TIME_BOUNDS;
+        const current = parseTimePayload(this.getValue() ?? "");
+        const candidates = TIME_FIELDS.map((spec) => {
+            const lo = spec.lo(bounds);
+            const hi = spec.hi(bounds);
+            return {
+                id: spec.key,
+                name: spec.key,
+                subtitle: `${lo} ~ ${hi === Number.MAX_SAFE_INTEGER ? "∞" : hi}`
+            };
+        });
+        dispatchPickerRequest({
+            kind: "time",
+            title: "选择时间",
+            candidates,
+            currentValue: this.getValue() ?? "",
+            onSelect: (id) => this.setValue(id)
+        });
+        // 触发 picker 后附带 currentValue 让 UI 层可解析已存值并渲染表单
+        void current;
+    }
+    getText_() {
+        const value = this.getValue();
+        if (value === null || value === undefined || value.length === 0) {
+            return PLACEHOLDER_LABEL;
+        }
+        return formatTimeLabel(parseTimePayload(value));
+    }
+}

package/dist/fields/picker-events.d.ts

@@ -0,0 +1,21 @@
+import type { BlocksEditorCtx } from "../blocks/ctx.js";
+export declare const PICKER_EVENT_NAME: "blocks-editor:open-picker";
+export type PickerKind = "entity" | "attr" | "edge" | "state" | "time" | "variable";
+export interface PickerCandidate {
+    readonly id: string;
+    readonly name: string;
+    readonly subtitle?: string;
+}
+export interface PickerRequestDetail {
+    readonly kind: PickerKind;
+    readonly title: string;
+    readonly candidates: ReadonlyArray<PickerCandidate>;
+    readonly currentValue: string;
+    readonly onSelect: (value: string) => void;
+    readonly onCancel?: () => void;
+}
+export declare function dispatchPickerRequest(detail: PickerRequestDetail): void;
+export declare function toEntityCandidates(ctx: BlocksEditorCtx): PickerCandidate[];
+export declare function toAttrCandidates(ctx: BlocksEditorCtx, entityId: string): PickerCandidate[];
+export declare function toEdgeCandidates(ctx: BlocksEditorCtx): PickerCandidate[];
+export declare function toStateCandidates(ctx: BlocksEditorCtx, entityId: string): PickerCandidate[];

package/dist/fields/picker-events.js

@@ -0,0 +1,28 @@
+export const PICKER_EVENT_NAME = "blocks-editor:open-picker";
+export function dispatchPickerRequest(detail) {
+    if (typeof window === "undefined")
+        return;
+    window.dispatchEvent(new CustomEvent(PICKER_EVENT_NAME, { detail }));
+}
+export function toEntityCandidates(ctx) {
+    return ctx.entity_list.map((e) => ({ id: e.id, name: e.name }));
+}
+export function toAttrCandidates(ctx, entityId) {
+    const entity = ctx.entity_list.find((e) => e.id === entityId);
+    if (!entity)
+        return [];
+    return entity.attrs.map((a) => ({ id: a.key, name: a.label }));
+}
+export function toEdgeCandidates(ctx) {
+    const edges = ctx.edge_list ?? [];
+    return edges.map((e) => ({
+        id: e.id,
+        name: e.label,
+        subtitle: `${e.src_id} → ${e.dst_id}`
+    }));
+}
+export function toStateCandidates(ctx, entityId) {
+    const entity = ctx.entity_list.find((e) => e.id === entityId);
+    const states = entity?.states ?? [];
+    return states.map((s) => ({ id: s.key, name: s.label }));
+}