@arronqzy/blueprint-dsl 1.0.8 → 1.0.10

package/src/index.ts

@@ -1,33 +0,0 @@
-export * from "./type.js";
-export * from "./lifecycle.js";
-export * from "./node-signal.js";
-export * from "./blueprint-signal.js";
-export * from "./core/behavior.js";
-export * from "./core/behavior-registry.js";
-export * from "./core/executor.js";
-export * from "./behaviors/default.js";
-export * from "./fetch-config.js";
-export * from "./scope-template.js";
-export * from "./scope-autocomplete.js";
-export * from "./incoming-node-scope.js";
-export * from "./json-config.js";
-export * from "./logic-config.js";
-export * from "./clock-config.js";
-export * from "./event-config.js";
-export * from "./swagger.js";
-export * from "./runtime/execution-trace.js";
-export * from "./runtime/blueprint-cycle.js";
-export * from "./runtime/graph-runner.js";
-export {
-  buildClockSessionKey,
-  scheduleClockOutputs,
-  createClockOutputValue,
-  abortClockNode,
-  isClockScheduleActive,
-} from "./runtime/clock-scheduler.js";
-export {
-  isClockNodeActive,
-  getActiveClockNodeIds,
-  subscribeActiveClockNodes,
-} from "./runtime/clock-active-registry.js";
-export * from "./nodes/definitions.js";

package/src/json-config.ts

@@ -1,37 +0,0 @@
-export type JsonNodeConfig = {
-  jsonString: string;
-};
-
-export const DEFAULT_JSON_NODE_CONFIG: JsonNodeConfig = {
-  jsonString: "{}",
-};
-
-export function validateJsonString(
-  jsonString: string
-): { ok: true; value: unknown } | { ok: false; error: string } {
-  const raw = jsonString?.trim();
-  if (!raw) {
-    return { ok: false, error: "JSON 不能为空" };
-  }
-
-  try {
-    const value = JSON.parse(raw) as unknown;
-    if (value === null || typeof value !== "object") {
-      return { ok: false, error: "JSON 根节点必须是 object 或 array" };
-    }
-    return { ok: true, value };
-  } catch (error) {
-    return {
-      ok: false,
-      error: error instanceof Error ? error.message : "JSON 格式无效",
-    };
-  }
-}
-
-export function parseJsonConfig(config: JsonNodeConfig): unknown {
-  const result = validateJsonString(config.jsonString ?? "");
-  if (!result.ok) {
-    throw new Error(result.error);
-  }
-  return result.value;
-}

package/src/lifecycle.ts

@@ -1,45 +0,0 @@
-/** 页面生命周期阶段 */
-export const PAGE_LIFECYCLE_PHASES = [
-  "created",
-  "beforeMount",
-  "mounted",
-  "updated",
-  "beforeDestroy",
-  "destroy",
-  "activated",
-  "deactivated",
-  /** 被其他蓝图的蓝图配置节点引用且收到真信号时触发 */
-  "blueprintActivated",
-] as const;
-
-export type PageLifecyclePhase = (typeof PAGE_LIFECYCLE_PHASES)[number];
-
-export type LifecycleSignal = {
-  /** 触发的生命周期枚举 */
-  phase: PageLifecyclePhase;
-  /** 触发时刻（Unix 毫秒时间戳） */
-  timestamp: number;
-  /** ISO 8601 时间字符串，便于下游节点展示或日志 */
-  isoTime: string;
-};
-
-export const PAGE_LIFECYCLE_LABELS: Record<PageLifecyclePhase, string> = {
-  created: "已创建 (created)",
-  beforeMount: "挂载前 (beforeMount)",
-  mounted: "已挂载 (mounted)",
-  updated: "已更新 (updated)",
-  beforeDestroy: "销毁前 (beforeDestroy)",
-  destroy: "已销毁 (destroy)",
-  activated: "已激活 (activated)",
-  deactivated: "已停用 (deactivated)",
-  blueprintActivated: "蓝图激活 (blueprintActivated)",
-};
-
-export function createLifecycleSignal(phase: PageLifecyclePhase): LifecycleSignal {
-  const timestamp = Date.now();
-  return {
-    phase,
-    timestamp,
-    isoTime: new Date(timestamp).toISOString(),
-  };
-}

package/src/logic-config.ts

@@ -1,53 +0,0 @@
-export type LogicNodeConfig = {
-  /** 用户手写的 update(input) 函数脚本 */
-  sourceCode: string;
-};
-
-export const DEFAULT_LOGIC_NODE_CONFIG: LogicNodeConfig = {
-  sourceCode: `function update(input) {
-  return input;
-}`,
-};
-
-function compileLogicRunner(sourceCode: string): (input: unknown) => unknown {
-  return new Function(
-    "input",
-    `"use strict";
-${sourceCode}
-if (typeof update !== "function") {
-  throw new TypeError("需要定义 update(input) 函数");
-}
-return update(input);`
-  ) as (input: unknown) => unknown;
-}
-
-export function validateLogicSourceCode(
-  sourceCode: string
-): { ok: true } | { ok: false; error: string } {
-  const raw = sourceCode?.trim();
-  if (!raw) {
-    return { ok: false, error: "代码不能为空" };
-  }
-
-  try {
-    compileLogicRunner(raw);
-    return { ok: true };
-  } catch (error) {
-    return {
-      ok: false,
-      error: error instanceof Error ? error.message : "JavaScript 语法错误",
-    };
-  }
-}
-
-export function executeLogicConfig(
-  config: LogicNodeConfig,
-  input: unknown
-): unknown {
-  const validation = validateLogicSourceCode(config.sourceCode ?? "");
-  if (!validation.ok) {
-    throw new Error(validation.error);
-  }
-  const run = compileLogicRunner(config.sourceCode);
-  return run(input);
-}

package/src/node-signal.ts

@@ -1,83 +0,0 @@
-import type { Value } from "./type.js";
-
-/** 真信号：节点正常执行完成时的输出 */
-export type TrueSignal<T = Value> = {
-  kind: "true";
-  value: T;
-  timestamp: number;
-  isoTime: string;
-};
-
-/** 假信号：节点执行出错时的输出 */
-export type FalseSignal = {
-  kind: "false";
-  error: string;
-  timestamp: number;
-  isoTime: string;
-};
-
-export type NodeSignal<T = Value> = TrueSignal<T> | FalseSignal;
-
-export function isTrueSignal<T = Value>(
-  signal: unknown
-): signal is TrueSignal<T> {
-  return (
-    !!signal &&
-    typeof signal === "object" &&
-    (signal as TrueSignal).kind === "true"
-  );
-}
-
-export function isFalseSignal(signal: unknown): signal is FalseSignal {
-  return (
-    !!signal &&
-    typeof signal === "object" &&
-    (signal as FalseSignal).kind === "false"
-  );
-}
-
-export function createTrueSignal<T = Value>(value: T): TrueSignal<T> {
-  const timestamp = Date.now();
-  return {
-    kind: "true",
-    value,
-    timestamp,
-    isoTime: new Date(timestamp).toISOString(),
-  };
-}
-
-export function createFalseSignal(error: string): FalseSignal {
-  const timestamp = Date.now();
-  return {
-    kind: "false",
-    error,
-    timestamp,
-    isoTime: new Date(timestamp).toISOString(),
-  };
-}
-
-/**
- * 同一输入端口连 n 条线时的「或」语义：任一为真则端口为真；
- * 若无真且存在假信号则合并为假；全无连线则为 undefined。
- */
-export function combinePortSignalsOr(
-  values: Array<Value | undefined>
-): Value | undefined {
-  const defined = values.filter((value) => value !== undefined);
-  if (defined.length === 0) return undefined;
-
-  for (const value of defined) {
-    if (isTrueSignal(value)) {
-      return createTrueSignal(value.value);
-    }
-  }
-
-  const falseSignals = defined.filter(isFalseSignal);
-  if (falseSignals.length > 0) {
-    return createFalseSignal(
-      falseSignals.map((signal) => signal.error).join("；")
-    );
-  }
-
-  return undefined;
-}

package/src/nodes/definitions.ts

@@ -1,105 +0,0 @@
-import type { NodeDefinition } from "../type.js";
-
-export const BLUEPRINT_NODE_TYPE = "Blueprint";
-export const DEFAULT_LOGIC_NODE_TYPE = "Logic";
-export const LIFECYCLE_NODE_TYPE = "Lifecycle";
-export const FETCH_NODE_TYPE = "DataFetch";
-export const JSON_NODE_TYPE = "JsonNode";
-export const CLOCK_NODE_TYPE = "Clock";
-export const AND_NODE_TYPE = "AndLogic";
-export const VIEW_NODE_TYPE = "ViewBind";
-export const EVENT_NODE_TYPE = "ViewEvent";
-
-/** 蓝图引用节点：单入单出，收到真信号后执行嵌套蓝图 */
-export const blueprintNodeDefinition: NodeDefinition = {
-  type: BLUEPRINT_NODE_TYPE,
-  inputs: [{ name: "in", kind: "data" }],
-  outputs: [{ name: "out", kind: "data" }],
-  behavior: { kind: "js", ref: "blueprint-ref-run" },
-};
-
-export const defaultLogicNodeDefinition: NodeDefinition = {
-  type: DEFAULT_LOGIC_NODE_TYPE,
-  inputs: [{ name: "in", kind: "data", optional: true }],
-  outputs: [{ name: "out", kind: "data" }],
-  behavior: { kind: "js", ref: "logic-run" },
-};
-
-/** 生命周期钩子节点：无入流，触发后向下游发出真/假信号 */
-export const lifecycleNodeDefinition: NodeDefinition = {
-  type: LIFECYCLE_NODE_TYPE,
-  inputs: [],
-  outputs: [{ name: "out", kind: "data" }],
-  behavior: { kind: "js", ref: "lifecycle-emit" },
-};
-
-/** 数据源获取：收到真信号后发起 fetch，成功/失败输出对应信号 */
-export const fetchNodeDefinition: NodeDefinition = {
-  type: FETCH_NODE_TYPE,
-  inputs: [{ name: "in", kind: "data" }],
-  outputs: [{ name: "out", kind: "data" }],
-  behavior: { kind: "js", ref: "fetch-run" },
-};
-
-/** JSON 解析：收到真信号后将配置的 JSON 转为 object 输出 */
-export const jsonNodeDefinition: NodeDefinition = {
-  type: JSON_NODE_TYPE,
-  inputs: [{ name: "in", kind: "data" }],
-  outputs: [{ name: "out", kind: "data" }],
-  behavior: { kind: "js", ref: "json-parse-run" },
-};
-
-/** 时钟节点：收到真信号后按间隔输出含当前时间的真信号 */
-export const clockNodeDefinition: NodeDefinition = {
-  type: CLOCK_NODE_TYPE,
-  inputs: [{ name: "in", kind: "data" }],
-  outputs: [{ name: "out", kind: "data" }],
-  behavior: { kind: "js", ref: "clock-run" },
-};
-
-/** 并运算：两路输入均为真时输出真信号；单端口多连线按「或」合并 */
-export const andLogicNodeDefinition: NodeDefinition = {
-  type: AND_NODE_TYPE,
-  inputs: [
-    { name: "inA", kind: "data" },
-    { name: "inB", kind: "data" },
-  ],
-  outputs: [{ name: "out", kind: "data" }],
-  behavior: { kind: "js", ref: "and-run" },
-};
-
-/** 视图绑定节点：收到信号后为关联视图元素写入 scope，并向下游透传 */
-export const viewBindNodeDefinition: NodeDefinition = {
-  type: VIEW_NODE_TYPE,
-  inputs: [{ name: "in", kind: "data" }],
-  outputs: [{ name: "out", kind: "data" }],
-  behavior: { kind: "js", ref: "view-bind-run" },
-};
-
-/** 视图事件节点：输入必须来自生命周期节点，对应阶段触发后注册事件，视图事件发生时输出真信号 */
-export const viewEventNodeDefinition: NodeDefinition = {
-  type: EVENT_NODE_TYPE,
-  inputs: [{ name: "in", kind: "data" }],
-  outputs: [{ name: "out", kind: "data" }],
-  behavior: { kind: "js", ref: "event-emit" },
-};
-
-export const nodeDefinitionRegistry: Record<string, NodeDefinition> = {
-  [BLUEPRINT_NODE_TYPE]: blueprintNodeDefinition,
-  [DEFAULT_LOGIC_NODE_TYPE]: defaultLogicNodeDefinition,
-  [LIFECYCLE_NODE_TYPE]: lifecycleNodeDefinition,
-  [FETCH_NODE_TYPE]: fetchNodeDefinition,
-  [JSON_NODE_TYPE]: jsonNodeDefinition,
-  [CLOCK_NODE_TYPE]: clockNodeDefinition,
-  [AND_NODE_TYPE]: andLogicNodeDefinition,
-  [VIEW_NODE_TYPE]: viewBindNodeDefinition,
-  [EVENT_NODE_TYPE]: viewEventNodeDefinition,
-};
-
-export function getNodeDefinition(type: string): NodeDefinition {
-  const def = nodeDefinitionRegistry[type];
-  if (!def) {
-    throw new Error(`NodeDefinition not found: ${type}`);
-  }
-  return def;
-}

package/src/runtime/blueprint-cycle.ts

@@ -1,136 +0,0 @@
-import { BLUEPRINT_NODE_TYPE } from "../nodes/definitions.js";
-import type { LibraryBlueprintResolver, RunnableGraph } from "./graph-runner.js";
-
-export const BLUEPRINT_CALL_STACK_KEY = "__blueprintCallStack";
-
-export class BlueprintCycleError extends Error {
-  readonly cycleIds: string[];
-
-  constructor(cycleIds: string[], message: string) {
-    super(message);
-    this.name = "BlueprintCycleError";
-    this.cycleIds = cycleIds;
-  }
-}
-
-export function collectBlueprintLibraryRefs(graph: RunnableGraph): string[] {
-  const ids = new Set<string>();
-  for (const node of graph.nodes) {
-    if (node.nodeType === BLUEPRINT_NODE_TYPE && node.libraryBlueprintId) {
-      ids.add(node.libraryBlueprintId);
-    }
-  }
-  return [...ids];
-}
-
-export function formatBlueprintCycleMessage(
-  cycleIds: string[],
-  resolveName?: (libraryBlueprintId: string) => string
-): string {
-  const labels = cycleIds.map((id) => resolveName?.(id) ?? id);
-  return `蓝图引用存在死循环：${labels.join(" → ")}`;
-}
-
-export type BlueprintCycleCheckOptions = {
-  rootGraph: RunnableGraph;
-  /** 当前蓝图对应的蓝图库 id；工作区蓝图未入库时为 null */
-  rootLibraryBlueprintId?: string | null;
-  resolveLibraryBlueprint: LibraryBlueprintResolver;
-  resolveBlueprintName?: (libraryBlueprintId: string) => string;
-};
-
-export type BlueprintCycleCheckResult =
-  | { ok: true }
-  | { ok: false; cycleIds: string[]; message: string };
-
-export async function detectBlueprintReferenceCycle(
-  options: BlueprintCycleCheckOptions
-): Promise<BlueprintCycleCheckResult> {
-  const {
-    rootGraph,
-    rootLibraryBlueprintId,
-    resolveLibraryBlueprint,
-    resolveBlueprintName,
-  } = options;
-
-  const graphCache = new Map<string, RunnableGraph | null>();
-
-  const loadGraph = async (libraryBlueprintId: string) => {
-    if (!graphCache.has(libraryBlueprintId)) {
-      graphCache.set(
-        libraryBlueprintId,
-        await resolveLibraryBlueprint(libraryBlueprintId)
-      );
-    }
-    return graphCache.get(libraryBlueprintId) ?? null;
-  };
-
-  const visit = async (
-    path: string[],
-    graph: RunnableGraph
-  ): Promise<string[] | null> => {
-    for (const refId of collectBlueprintLibraryRefs(graph)) {
-      const cycleIndex = path.indexOf(refId);
-      if (cycleIndex !== -1) {
-        return [...path.slice(cycleIndex), refId];
-      }
-
-      const nested = await loadGraph(refId);
-      if (!nested) continue;
-
-      const cycle = await visit([...path, refId], nested);
-      if (cycle) return cycle;
-    }
-    return null;
-  };
-
-  const initialPath = rootLibraryBlueprintId ? [rootLibraryBlueprintId] : [];
-  const cycleIds = await visit(initialPath, rootGraph);
-
-  if (!cycleIds) {
-    return { ok: true };
-  }
-
-  return {
-    ok: false,
-    cycleIds,
-    message: formatBlueprintCycleMessage(cycleIds, resolveBlueprintName),
-  };
-}
-
-export async function assertNoBlueprintReferenceCycle(
-  options: BlueprintCycleCheckOptions
-): Promise<void> {
-  const result = await detectBlueprintReferenceCycle(options);
-  if (!result.ok) {
-    throw new BlueprintCycleError(result.cycleIds, result.message);
-  }
-}
-
-export function resolveBlueprintCallStack(
-  scopeStack: string[] | undefined,
-  rootLibraryBlueprintId?: string | null
-): string[] {
-  if (scopeStack) return scopeStack;
-  return rootLibraryBlueprintId ? [rootLibraryBlueprintId] : [];
-}
-
-export function detectRuntimeBlueprintCycle(
-  callStack: string[],
-  targetLibraryBlueprintId: string,
-  resolveName?: (libraryBlueprintId: string) => string
-): BlueprintCycleCheckResult {
-  const cycleIndex = callStack.indexOf(targetLibraryBlueprintId);
-  if (cycleIndex === -1) {
-    return { ok: true };
-  }
-  const cycleIds = [
-    ...callStack.slice(cycleIndex),
-    targetLibraryBlueprintId,
-  ];
-  return {
-    ok: false,
-    cycleIds,
-    message: formatBlueprintCycleMessage(cycleIds, resolveName),
-  };
-}

package/src/runtime/clock-active-registry.ts

@@ -1,30 +0,0 @@
-const activeClockNodeIds = new Set<string>();
-const listeners = new Set<() => void>();
-
-function emit() {
-  listeners.forEach((listener) => listener());
-}
-
-export function markClockNodeActive(nodeId: string) {
-  if (activeClockNodeIds.has(nodeId)) return;
-  activeClockNodeIds.add(nodeId);
-  emit();
-}
-
-export function markClockNodeInactive(nodeId: string) {
-  if (!activeClockNodeIds.delete(nodeId)) return;
-  emit();
-}
-
-export function isClockNodeActive(nodeId: string): boolean {
-  return activeClockNodeIds.has(nodeId);
-}
-
-export function getActiveClockNodeIds(): string[] {
-  return [...activeClockNodeIds];
-}
-
-export function subscribeActiveClockNodes(listener: () => void) {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
-}

package/src/runtime/clock-scheduler.ts

@@ -1,49 +0,0 @@
-import {
-  buildClockSignalValue,
-  normalizeClockConfig,
-  startClockSchedule,
-  stopAllClockSchedules,
-  stopClockSchedule,
-  abortClockSession,
-  isClockScheduleActive,
-  isClockSessionAborted,
-  clearClockSessionAbort,
-  validateClockScheduleConfig,
-  type ClockNodeConfig,
-} from "../clock-config.js";
-import {
-  markClockNodeActive,
-  markClockNodeInactive,
-} from "./clock-active-registry.js";
-
-export function buildClockSessionKey(scopeId: string, nodeId: string): string {
-  return `${scopeId}:${nodeId}`;
-}
-
-export function abortClockNode(scopeId: string, nodeId: string): void {
-  abortClockSession(buildClockSessionKey(scopeId, nodeId));
-  markClockNodeInactive(nodeId);
-}
-
-export function scheduleClockOutputs(options: {
-  sessionKey: string;
-  config: ClockNodeConfig;
-  onTick: () => void | Promise<void>;
-  onSettled?: () => void;
-}): () => void {
-  return startClockSchedule(options);
-}
-
-export {
-  stopClockSchedule,
-  stopAllClockSchedules,
-  abortClockSession,
-  isClockScheduleActive,
-  isClockSessionAborted,
-  clearClockSessionAbort,
-  validateClockScheduleConfig,
-};
-
-export function createClockOutputValue(config: ClockNodeConfig) {
-  return buildClockSignalValue(normalizeClockConfig(config));
-}

package/src/runtime/execution-trace.ts

@@ -1,55 +0,0 @@
-import type { Value } from "../type.js";
-import { isFalseSignal, isTrueSignal } from "../node-signal.js";
-
-export type ExecutionTraceEntry = {
-  id: string;
-  nodeId: string;
-  nodeLabel?: string;
-  nodeType: string;
-  startedAt: number;
-  finishedAt: number;
-  isoTime: string;
-  inputs: Record<string, unknown>;
-  outputs: Record<string, unknown>;
-  error?: string;
-  /** 时钟节点第几次 tick（从 1 开始） */
-  clockTickIndex?: number;
-  /** 时钟节点本次调度总 tick 数 */
-  clockTickTotal?: number;
-};
-
-export type ExecutionRunRecord = {
-  runId: string;
-  blueprintId: string | null;
-  blueprintName: string;
-  lifecycleNodeId: string;
-  lifecycleNodeLabel?: string;
-  lifecyclePhase?: string;
-  startedAt: number;
-  finishedAt?: number;
-  status: "running" | "completed" | "paused" | "failed";
-  entries: ExecutionTraceEntry[];
-};
-
-export function serializeTraceValue(value: Value | undefined): unknown {
-  if (value === undefined) return undefined;
-  if (isTrueSignal(value)) {
-    return {
-      kind: "true",
-      value: value.value,
-      isoTime: value.isoTime,
-    };
-  }
-  if (isFalseSignal(value)) {
-    return {
-      kind: "false",
-      error: value.error,
-      isoTime: value.isoTime,
-    };
-  }
-  return value;
-}
-
-export function createTraceEntryId() {
-  return `trace_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-}