@arronqzy/blueprint-dsl 0.0.1

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@arronqzy/blueprint-dsl",
+  "version": "0.0.1",
+  "description": "Abuilder blueprint DSL runtime",
+  "license": "MIT",
+  "files": [
+    "src",
+    "readme.md"
+  ],
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "rxjs": "^7.8.2"
+  },
+  "devDependencies": {
+    "eslint": "^8.57.0",
+    "typescript": "^5.5.4",
+    "@arronqzy/eslint-config": "0.0.0",
+    "@arronqzy/typescript-config": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "build": "pnpm run typecheck",
+    "dev": "pnpm run typecheck --watch"
+  }
+}

package/readme.md

@@ -0,0 +1,32 @@
+```ts
+const behaviors = new BehaviorRegistry();
+
+behaviors.registerJS("print-js", async ({ io }) => {
+  console.log(await io.getInput("msg"));
+  io.emitFlow("out");
+});
+
+behaviors.registerJS("sleep-js", async ({ io }) => {
+  const ms = await io.getInput("ms");
+  await new Promise((r) => setTimeout(r, ms));
+  io.emitFlow("out");
+});
+
+
+const PrintNode: NodeDefinition = {
+  type: "Print",
+  inputs: [{ name: "msg", kind: "data" }],
+  outputs: [{ name: "out", kind: "flow" }],
+  behavior: { kind: "js", ref: "print-js" }
+}
+
+
+await executor.executeToken({
+  tokenId: "t1",
+  nodeId: "n1",
+  nodeType: "Print",
+  inPort: "in",
+  scope: { vars: new Map() }
+})
+
+```

package/src/behaviors/default.ts

@@ -0,0 +1,44 @@
+import {
+  createFalseSignal,
+  createTrueSignal,
+  isFalseSignal,
+  isTrueSignal,
+} from "../node-signal.js";
+import type { LifecycleSignal } from "../lifecycle.js";
+import { BehaviorRegistry } from "../core/behavior-registry.js";
+
+const LIFECYCLE_SIGNAL_KEY = "__lifecycleSignal";
+const BLUEPRINT_ACTIVATION_INPUT_KEY = "__blueprintActivationInput";
+
+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");
+  });
+}
+
+export { LIFECYCLE_SIGNAL_KEY, BLUEPRINT_ACTIVATION_INPUT_KEY };

package/src/blueprint-signal.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,232 @@
+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

@@ -0,0 +1,32 @@
+// 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

@@ -0,0 +1,13 @@
+// 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

@@ -0,0 +1,51 @@
+// 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

@@ -0,0 +1,13 @@
+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)
+  }
+}