@arronqzy/blueprint-dsl 1.0.8 → 1.0.10

package/src/behaviors/default.ts

@@ -1,64 +0,0 @@
-import {
-  createFalseSignal,
-  createTrueSignal,
-  isFalseSignal,
-  isTrueSignal,
-} from "../node-signal.js";
-import type { LifecycleSignal } from "../lifecycle.js";
-import type { ViewEventSignal } from "../event-config.js";
-import { BehaviorRegistry } from "../core/behavior-registry.js";
-
-const LIFECYCLE_SIGNAL_KEY = "__lifecycleSignal";
-const BLUEPRINT_ACTIVATION_INPUT_KEY = "__blueprintActivationInput";
-const UI_EVENT_PAYLOAD_KEY = "__uiEventPayload";
-const VIEW_EVENT_SIGNAL_KEY = "__viewEventSignal";
-
-export function registerDefaultBehaviors(registry: BehaviorRegistry) {
-  registry.registerJS("logic-noop", async ({ io }) => {
-    const input = await io.getInput("in");
-    if (isFalseSignal(input)) {
-      io.setOutput("out", input);
-    } else if (isTrueSignal(input)) {
-      io.setOutput("out", createTrueSignal(input.value));
-    } else {
-      io.setOutput("out", createTrueSignal(undefined));
-    }
-    io.emitFlow("out");
-  });
-
-  registry.registerJS("lifecycle-emit", async ({ token, io }) => {
-    const lifecycle = token.scope.vars.get(LIFECYCLE_SIGNAL_KEY) as
-      | LifecycleSignal
-      | undefined;
-    if (!lifecycle) {
-      io.setOutput("out", createFalseSignal("生命周期信号缺失"));
-    } else if (lifecycle.phase === "blueprintActivated") {
-      io.setOutput(
-        "out",
-        createTrueSignal(token.scope.vars.get(BLUEPRINT_ACTIVATION_INPUT_KEY))
-      );
-    } else {
-      io.setOutput("out", createTrueSignal(lifecycle));
-    }
-    io.emitFlow("out");
-  });
-
-  registry.registerJS("event-emit", async ({ token, io }) => {
-    const payload = token.scope.vars.get(VIEW_EVENT_SIGNAL_KEY) as
-      | ViewEventSignal
-      | undefined;
-    if (!payload) {
-      // 生命周期输入只负责注册，不向下游发出信号
-      return;
-    }
-    io.setOutput("out", createTrueSignal(payload));
-    io.emitFlow("out");
-  });
-}
-
-export {
-  LIFECYCLE_SIGNAL_KEY,
-  BLUEPRINT_ACTIVATION_INPUT_KEY,
-  UI_EVENT_PAYLOAD_KEY,
-  VIEW_EVENT_SIGNAL_KEY,
-};

package/src/blueprint-signal.ts

@@ -1,14 +0,0 @@
-import type { Value } from "./type.js";
-
-/** 嵌套蓝图执行完成后各节点的端口输出 */
-export type BlueprintNodeOutputs = Record<string, Record<string, Value>>;
-
-/** 蓝图引用节点真信号携带的输出值 */
-export type BlueprintRefOutput = {
-  nodeId: string;
-  nodeType: string;
-  libraryBlueprintId: string;
-  blueprintName?: string;
-  /** 嵌套蓝图各节点 out 端口的信号输出 */
-  nestedOutputs: BlueprintNodeOutputs;
-};

package/src/clock-config.ts

@@ -1,232 +0,0 @@
-export type ClockNodeConfig = {
-  /** 两次输出之间的间隔秒数 */
-  intervalSeconds: number;
-  /** 输出值中的时间格式化模板，支持 YYYY、MM、DD、HH、mm、ss */
-  timeFormat: string;
-  /** 收到真信号后的输出次数，默认 1 */
-  outputCount: number;
-  /** 收到真信号后立即输出第一次，再按间隔继续；关闭则首次也等待 n 秒 */
-  emitImmediately: boolean;
-};
-
-export type ClockSignalOutput = {
-  /** 按 timeFormat 格式化后的当前时间 */
-  formatted: string;
-  /** Unix 毫秒时间戳 */
-  timestamp: number;
-  /** ISO 8601 时间字符串 */
-  isoTime: string;
-};
-
-export const DEFAULT_CLOCK_NODE_CONFIG: ClockNodeConfig = {
-  intervalSeconds: 0,
-  timeFormat: "YYYY-MM-DD HH:mm:ss",
-  outputCount: 1,
-  emitImmediately: true,
-};
-
-export function normalizeClockConfig(
-  config?: Partial<ClockNodeConfig> | null
-): ClockNodeConfig {
-  const intervalRaw = Number(config?.intervalSeconds);
-  const intervalSeconds =
-    Number.isFinite(intervalRaw) && intervalRaw > 0
-      ? Math.floor(intervalRaw)
-      : 0;
-
-  const outputCountRaw = Number(config?.outputCount);
-  const outputCount =
-    Number.isFinite(outputCountRaw) && outputCountRaw > 0
-      ? Math.floor(outputCountRaw)
-      : DEFAULT_CLOCK_NODE_CONFIG.outputCount;
-
-  const timeFormat =
-    config?.timeFormat?.trim() || DEFAULT_CLOCK_NODE_CONFIG.timeFormat;
-
-  return {
-    intervalSeconds,
-    timeFormat,
-    outputCount,
-    emitImmediately: config?.emitImmediately !== false,
-  };
-}
-
-export function validateClockScheduleConfig(
-  config: ClockNodeConfig
-): { ok: true } | { ok: false; error: string } {
-  const normalized = normalizeClockConfig(config);
-
-  if (normalized.outputCount <= 0) {
-    return { ok: false, error: "输出次数须大于 0" };
-  }
-
-  const needsInterval =
-    normalized.outputCount > 1 ||
-    (normalized.outputCount === 1 && !normalized.emitImmediately);
-
-  if (needsInterval && normalized.intervalSeconds <= 0) {
-    return { ok: false, error: "当前配置下时钟信号间隔须大于 0 秒" };
-  }
-
-  return { ok: true };
-}
-
-const pad2 = (value: number) => String(value).padStart(2, "0");
-
-/** 将 Date 格式化为指定模板（YYYY/MM/DD/HH/mm/ss） */
-export function formatClockTime(date: Date, pattern: string): string {
-  const tokens: Record<string, string> = {
-    YYYY: String(date.getFullYear()).padStart(4, "0"),
-    MM: pad2(date.getMonth() + 1),
-    DD: pad2(date.getDate()),
-    HH: pad2(date.getHours()),
-    mm: pad2(date.getMinutes()),
-    ss: pad2(date.getSeconds()),
-  };
-
-  return pattern.replace(/YYYY|MM|DD|HH|mm|ss/g, (token) => tokens[token] ?? token);
-}
-
-export function buildClockSignalValue(
-  config: ClockNodeConfig,
-  now = new Date()
-): ClockSignalOutput {
-  const normalized = normalizeClockConfig(config);
-  return {
-    formatted: formatClockTime(now, normalized.timeFormat),
-    timestamp: now.getTime(),
-    isoTime: now.toISOString(),
-  };
-}
-
-function sleep(ms: number, abort: { aborted: boolean }, sessionKey?: string): Promise<void> {
-  if (ms <= 0 || abort.aborted) return Promise.resolve();
-  return new Promise((resolve) => {
-    const timerId = setTimeout(() => {
-      clearInterval(pollId);
-      resolve();
-    }, ms);
-    const pollId = setInterval(() => {
-      if (
-        abort.aborted ||
-        (sessionKey !== undefined && isClockSessionAborted(sessionKey))
-      ) {
-        clearTimeout(timerId);
-        clearInterval(pollId);
-        resolve();
-      }
-    }, 50);
-  });
-}
-
-/**
- * 第 tickIndex 次输出（从 0 起）相对调度起点的目标延迟（毫秒）。
- * - 立即发送且次数 > 1：第 1 次为 0，其余依次为 m、2m…
- * - 未立即发送：依次为 m、2m、3m…
- */
-export function getClockTickDelayOffsetMs(
-  config: ClockNodeConfig,
-  tickIndex: number
-): number {
-  const normalized = normalizeClockConfig(config);
-  const intervalMs = normalized.intervalSeconds * 1000;
-
-  if (tickIndex <= 0) {
-    return normalized.emitImmediately ? 0 : intervalMs;
-  }
-
-  if (normalized.emitImmediately) {
-    return tickIndex * intervalMs;
-  }
-
-  return (tickIndex + 1) * intervalMs;
-}
-
-/** 距离第 tickIndex 次输出还应等待的毫秒数（基于调度起点） */
-export function getClockTickWaitMs(
-  config: ClockNodeConfig,
-  tickIndex: number,
-  scheduleStartMs: number,
-  nowMs = Date.now()
-): number {
-  const targetMs = scheduleStartMs + getClockTickDelayOffsetMs(config, tickIndex);
-  return Math.max(0, targetMs - nowMs);
-}
-
-const activeSessions = new Map<string, { aborted: boolean }>();
-const abortedClockSessions = new Set<string>();
-
-/** 停止指定会话的时钟调度 */
-export function stopClockSchedule(sessionKey: string): void {
-  const session = activeSessions.get(sessionKey);
-  if (!session) return;
-  session.aborted = true;
-  activeSessions.delete(sessionKey);
-}
-
-export function isClockScheduleActive(sessionKey: string): boolean {
-  return activeSessions.has(sessionKey);
-}
-
-/** 中止时钟：取消剩余 tick，并标记会话供下游传播循环检测 */
-export function abortClockSession(sessionKey: string): void {
-  stopClockSchedule(sessionKey);
-  abortedClockSessions.add(sessionKey);
-}
-
-export function isClockSessionAborted(sessionKey: string): boolean {
-  return abortedClockSessions.has(sessionKey);
-}
-
-export function clearClockSessionAbort(sessionKey: string): void {
-  abortedClockSessions.delete(sessionKey);
-}
-
-/**
- * 按配置依次触发 onTick；新的调度会取消同 sessionKey 的上一次调度。
- * 返回取消函数。
- */
-export function startClockSchedule(options: {
-  sessionKey: string;
-  config: ClockNodeConfig;
-  onTick: () => void | Promise<void>;
-  onSettled?: () => void;
-}): () => void {
-  stopClockSchedule(options.sessionKey);
-  clearClockSessionAbort(options.sessionKey);
-
-  const abort = { aborted: false };
-  activeSessions.set(options.sessionKey, abort);
-
-  void (async () => {
-    try {
-      const config = normalizeClockConfig(options.config);
-      const total = config.outputCount;
-      const scheduleStartMs = Date.now();
-
-      for (let tickIndex = 0; tickIndex < total; tickIndex++) {
-        if (abort.aborted || isClockSessionAborted(options.sessionKey)) return;
-
-        const waitMs = getClockTickWaitMs(config, tickIndex, scheduleStartMs);
-        if (waitMs > 0) {
-          await sleep(waitMs, abort, options.sessionKey);
-        }
-
-        if (abort.aborted || isClockSessionAborted(options.sessionKey)) return;
-        await options.onTick();
-      }
-    } finally {
-      activeSessions.delete(options.sessionKey);
-      options.onSettled?.();
-    }
-  })();
-
-  return () => stopClockSchedule(options.sessionKey);
-}
-
-/** 停止全部时钟调度（如蓝图面板卸载时） */
-export function stopAllClockSchedules(): void {
-  for (const key of [...activeSessions.keys()]) {
-    abortClockSession(key);
-  }
-}

package/src/core/behavior-registry.ts

@@ -1,32 +0,0 @@
-// behavior-registry.ts
-import { BehaviorFn } from "./behavior"
-
-type JSBehavior = {
-  kind: "js"
-  run: BehaviorFn
-}
-
-type BlueprintBehavior = {
-  kind: "blueprint"
-  blueprintId: string
-}
-
-export type Behavior = JSBehavior | BlueprintBehavior
-
-export class BehaviorRegistry {
-  private map = new Map<string, Behavior>()
-
-  registerJS(id: string, fn: BehaviorFn) {
-    this.map.set(id, { kind: "js", run: fn })
-  }
-
-  registerBlueprint(id: string, blueprintId: string) {
-    this.map.set(id, { kind: "blueprint", blueprintId })
-  }
-
-  get(id: string): Behavior {
-    const b = this.map.get(id)
-    if (!b) throw new Error(`Behavior not found: ${id}`)
-    return b
-  }
-}

package/src/core/behavior.ts

@@ -1,13 +0,0 @@
-// behavior.ts
-import { ExecutionToken, Value } from "../type.js"
-export type BehaviorContext = {
-  token: ExecutionToken
-
-  io: {
-    getInput(name: string): Promise<Value>
-    setOutput(name: string, value: Value): void
-    emitFlow(port?: string): void
-  }
-}
-
-export type BehaviorFn = (ctx: BehaviorContext) => Promise<void>

package/src/core/executor.ts

@@ -1,51 +0,0 @@
-// executor.ts
-import { BehaviorRegistry } from "./behavior-registry";
-import { NodeDefinition, ExecutionToken, Value } from "../type";
-
-export type ExecutorDeps = {
-  getNodeDefinition(type: string): NodeDefinition;
-  behaviors: BehaviorRegistry;
-
-  // 蓝图 runner（给 blueprint behavior 用）
-  runBlueprint: (args: {
-    blueprintId: string;
-    token: ExecutionToken;
-  }) => Promise<void>;
-
-  // 图能力（flow / data）
-  getInputValue: (token: ExecutionToken, port: string) => Promise<Value>;
-  setNodeOutput: (token: ExecutionToken, port: string, value: Value) => void;
-  emitFlow: (token: ExecutionToken, outPort: string) => void;
-};
-export class Executor {
-  constructor(private deps: ExecutorDeps) {}
-
-  async executeToken(token: ExecutionToken): Promise<void> {
-    const def = this.deps.getNodeDefinition(token.nodeType)
-    const behavior = this.deps.behaviors.get(def.behavior.ref)
-
-    const io = {
-      getInput: (name: string) =>
-        this.deps.getInputValue(token, name),
-
-      setOutput: (name: string, value: Value) =>
-        this.deps.setNodeOutput(token, name, value),
-
-      emitFlow: (port = "out") =>
-        this.deps.emitFlow(token, port),
-    }
-
-    if (behavior.kind === "js") {
-      await behavior.run({ token, io })
-      return
-    }
-
-    if (behavior.kind === "blueprint") {
-      await this.deps.runBlueprint({
-        blueprintId: behavior.blueprintId,
-        token,
-      })
-      return
-    }
-  }
-}

package/src/core/scheduler-loop.ts

@@ -1,13 +0,0 @@
-import { ExecutionToken } from "../type"
-import { Executor } from "./executor"
-
-// scheduler-loop.ts
-async function schedulerLoop(
-  queue: ExecutionToken[],
-  executor: Executor
-) {
-  while (queue.length > 0) {
-    const token = queue.shift()!
-    await executor.executeToken(token)
-  }
-}

package/src/event-config.ts

@@ -1,211 +0,0 @@
-/** 视图事件节点可监听的常用 DOM 事件 */
-export const VIEW_EVENT_TYPES = [
-  "click",
-  "dblclick",
-  "contextmenu",
-  "mouseenter",
-  "mouseleave",
-] as const;
-
-export type ViewEventType = (typeof VIEW_EVENT_TYPES)[number];
-
-export type ViewEventNodeConfig = {
-  /** 监听的事件类型，至少一项；默认 click */
-  eventTypes: ViewEventType[];
-};
-
-export const DEFAULT_VIEW_EVENT_NODE_CONFIG: ViewEventNodeConfig = {
-  eventTypes: ["click"],
-};
-
-const VIEW_EVENT_TYPE_SET = new Set<string>(VIEW_EVENT_TYPES);
-
-export function isViewEventType(value: unknown): value is ViewEventType {
-  return typeof value === "string" && VIEW_EVENT_TYPE_SET.has(value);
-}
-
-export function normalizeViewEventConfig(
-  config?: Partial<ViewEventNodeConfig> | null
-): ViewEventNodeConfig {
-  const raw = Array.isArray(config?.eventTypes) ? config.eventTypes : [];
-  const eventTypes = [
-    ...new Set(raw.filter(isViewEventType)),
-  ];
-  return {
-    eventTypes:
-      eventTypes.length > 0
-        ? eventTypes
-        : [...DEFAULT_VIEW_EVENT_NODE_CONFIG.eventTypes],
-  };
-}
-
-/** 可序列化的 DOM 事件快照（原生 Event 无法作为蓝图信号传递） */
-export type ViewEventSnapshot = {
-  type: string;
-  timeStamp: number;
-  clientX?: number;
-  clientY?: number;
-  pageX?: number;
-  pageY?: number;
-  button?: number;
-  altKey?: boolean;
-  ctrlKey?: boolean;
-  metaKey?: boolean;
-  shiftKey?: boolean;
-};
-
-/** 触发该事件的视图节点摘要 */
-export type ViewEventNodeSnapshot = {
-  id: string;
-  name?: string;
-  materialType?: string;
-  x?: number;
-  y?: number;
-  width?: number;
-  height?: number;
-  layerId?: string;
-};
-
-/** 事件节点向下游发出的真信号 value */
-export type ViewEventSignal = {
-  /** 触发事件（可序列化快照） */
-  event: ViewEventSnapshot;
-  /** 触发节点 */
-  node: ViewEventNodeSnapshot;
-  /** 触发的事件类型 */
-  eventType: ViewEventType;
-};
-
-export function snapshotDomEvent(event: {
-  type: string;
-  timeStamp?: number;
-  clientX?: number;
-  clientY?: number;
-  pageX?: number;
-  pageY?: number;
-  button?: number;
-  altKey?: boolean;
-  ctrlKey?: boolean;
-  metaKey?: boolean;
-  shiftKey?: boolean;
-}): ViewEventSnapshot {
-  return {
-    type: event.type,
-    timeStamp: Number(event.timeStamp) || Date.now(),
-    clientX: event.clientX,
-    clientY: event.clientY,
-    pageX: event.pageX,
-    pageY: event.pageY,
-    button: event.button,
-    altKey: event.altKey,
-    ctrlKey: event.ctrlKey,
-    metaKey: event.metaKey,
-    shiftKey: event.shiftKey,
-  };
-}
-
-export function snapshotViewEventNode(
-  node: Partial<ViewEventNodeSnapshot> & { id: string }
-): ViewEventNodeSnapshot {
-  return {
-    id: node.id,
-    name: node.name,
-    materialType: node.materialType,
-    x: node.x,
-    y: node.y,
-    width: node.width,
-    height: node.height,
-    layerId: node.layerId,
-  };
-}
-
-export function createViewEventSignal(input: {
-  event: ViewEventSnapshot;
-  node: ViewEventNodeSnapshot;
-  eventType: ViewEventType;
-}): ViewEventSignal {
-  return {
-    event: input.event,
-    node: input.node,
-    eventType: input.eventType,
-  };
-}
-
-export function collectArmedViewEventNodeIds(
-  nodes: Array<{
-    id: string;
-    nodeType?: string;
-    lifecyclePhase?: string;
-  }>,
-  edges: Array<{ source: string; target: string }>,
-  eventNodeType: string,
-  lifecycleNodeType: string,
-  firedPhases: ReadonlySet<string>
-): Set<string> {
-  const byId = new Map(nodes.map((node) => [node.id, node]));
-  const armed = new Set<string>();
-  for (const node of nodes) {
-    if (node.nodeType !== eventNodeType) continue;
-    const registered = edges.some((edge) => {
-      if (edge.target !== node.id) return false;
-      const source = byId.get(edge.source);
-      if (!source || source.nodeType !== lifecycleNodeType) return false;
-      const phase = source.lifecyclePhase || "mounted";
-      return firedPhases.has(phase);
-    });
-    if (registered) armed.add(node.id);
-  }
-  return armed;
-}
-
-/** 仅收集已由生命周期注册的事件节点绑定 */
-export function collectArmedViewEventBindings(
-  nodes: Array<{
-    id: string;
-    nodeType?: string;
-    lifecyclePhase?: string;
-    viewElementIds?: string[];
-    eventConfig?: Partial<ViewEventNodeConfig> | null;
-  }>,
-  edges: Array<{ source: string; target: string }>,
-  eventNodeType: string,
-  lifecycleNodeType: string,
-  firedPhases: ReadonlySet<string>
-): Map<string, Set<ViewEventType>> {
-  const armed = collectArmedViewEventNodeIds(
-    nodes,
-    edges,
-    eventNodeType,
-    lifecycleNodeType,
-    firedPhases
-  );
-  return collectViewEventBindings(nodes, eventNodeType, armed);
-}
-
-export function collectViewEventBindings(
-  nodes: Array<{
-    id?: string;
-    nodeType?: string;
-    viewElementIds?: string[];
-    eventConfig?: Partial<ViewEventNodeConfig> | null;
-  }>,
-  eventNodeType: string,
-  armedNodeIds?: ReadonlySet<string>
-): Map<string, Set<ViewEventType>> {
-  const map = new Map<string, Set<ViewEventType>>();
-  for (const node of nodes) {
-    if (node.nodeType !== eventNodeType) continue;
-    if (armedNodeIds && (!node.id || !armedNodeIds.has(node.id))) continue;
-    const types = normalizeViewEventConfig(node.eventConfig).eventTypes;
-    for (const id of node.viewElementIds ?? []) {
-      if (!id) continue;
-      let set = map.get(id);
-      if (!set) {
-        set = new Set();
-        map.set(id, set);
-      }
-      for (const type of types) set.add(type);
-    }
-  }
-  return map;
-}