@likec4/diagram 1.55.1 → 1.57.0

package/dist/adhoc-editor/state/actor.editor.js

@@ -1,205 +1,167 @@
-import { ModelFqnExpr } from '@likec4/core';
-import { nonexhaustive, invariant, stringHash } from '@likec4/core/utils';
-import { last } from 'remeda';
-import { assertEvent } from 'xstate';
-import { emitViewUpdate } from './actor.layouter.js';
-import { machine } from './actor.types.js';
-
-const to = {
-  idle: { target: "#idle" },
-  selecting: { target: "#selecting" },
-  layouting: { target: "#layouting" }
+import "../../_virtual/_rolldown/runtime.js";
+import { machine } from "./actor.types.js";
+import { emitViewUpdate } from "./actor.layouter.js";
+import { last } from "remeda";
+import { ModelFqnExpr } from "@likec4/core";
+import { invariant as invariant$1, nonexhaustive as nonexhaustive$1, stringHash } from "@likec4/core/utils";
+import { assertEvent } from "xstate";
+//#region src/adhoc-editor/state/actor.editor.ts
+var to = {
+	idle: { target: "#idle" },
+	selecting: { target: "#selecting" },
+	layouting: { target: "#layouting" }
 };
 function nextId({ rules }, salt = "") {
-  return stringHash((rules.at(-1)?.id ?? (/* @__PURE__ */ new Date()).toISOString()) + salt);
+	return stringHash((rules.at(-1)?.id ?? (/* @__PURE__ */ new Date()).toISOString()) + salt);
 }
-const isRuleOf = (fqn) => (rule) => {
-  return ModelFqnExpr.isModelRef(rule.expr) && rule.expr.ref.model === fqn;
+var isRuleOf = (fqn) => (rule) => {
+	return ModelFqnExpr.isModelRef(rule.expr) && rule.expr.ref.model === fqn;
 };
-const isIncludeOf = (fqn) => (rule) => {
-  return rule.type === "include" && ModelFqnExpr.isModelRef(rule.expr) && rule.expr.ref.model === fqn;
+var isIncludeOf = (fqn) => (rule) => {
+	return rule.type === "include" && ModelFqnExpr.isModelRef(rule.expr) && rule.expr.ref.model === fqn;
 };
-const isExcludeOf = (fqn) => (rule) => {
-  return rule.type === "exclude" && ModelFqnExpr.isModelRef(rule.expr) && rule.expr.ref.model === fqn;
+var isExcludeOf = (fqn) => (rule) => {
+	return rule.type === "exclude" && ModelFqnExpr.isModelRef(rule.expr) && rule.expr.ref.model === fqn;
 };
 function deriveElementState(id, { rules, view }) {
-  const ruleOf = rules.find(isRuleOf(id));
-  if (ruleOf && !ruleOf.enabled) {
-    return {
-      state: "disabled",
-      ruleId: ruleOf.id
-    };
-  }
-  const isIncludedInView = view ? view.nodes.some((node) => node.modelRef === id) : false;
-  const includeRule = rules.find(isIncludeOf(id));
-  const excludeRule = rules.find(isExcludeOf(id));
-  switch (true) {
-    case (includeRule && isIncludedInView):
-      return {
-        state: "include-explicit",
-        ruleId: includeRule.id
-      };
-    case (!includeRule && isIncludedInView):
-      return {
-        state: "include-implicit",
-        ruleId: void 0
-      };
-    case (includeRule && !isIncludedInView):
-      return {
-        state: "not-present",
-        ruleId: includeRule.id
-      };
-    case !!excludeRule:
-      return {
-        state: "exclude",
-        ruleId: excludeRule.id
-      };
-    default: {
-      invariant(isIncludedInView === false, "Element not in view should not be included or excluded by any rule");
-      return {
-        state: "not-present",
-        ruleId: void 0
-      };
-    }
-  }
+	const ruleOf = rules.find(isRuleOf(id));
+	if (ruleOf && !ruleOf.enabled) return {
+		state: "disabled",
+		ruleId: ruleOf.id
+	};
+	const isIncludedInView = view ? view.nodes.some((node) => node.modelRef === id) : false;
+	const includeRule = rules.find(isIncludeOf(id));
+	const excludeRule = rules.find(isExcludeOf(id));
+	switch (true) {
+		case includeRule && isIncludedInView: return {
+			state: "include-explicit",
+			ruleId: includeRule.id
+		};
+		case !includeRule && isIncludedInView: return {
+			state: "include-implicit",
+			ruleId: void 0
+		};
+		case includeRule && !isIncludedInView: return {
+			state: "not-present",
+			ruleId: includeRule.id
+		};
+		case !!excludeRule: return {
+			state: "exclude",
+			ruleId: excludeRule.id
+		};
+		default:
+			invariant$1(isIncludedInView === false, "Element not in view should not be included or excluded by any rule");
+			return {
+				state: "not-present",
+				ruleId: void 0
+			};
+	}
 }
-const enableRule = (ruleId) => machine.assign(({ context }) => {
-  return {
-    rules: context.rules.map((rule) => {
-      if (rule.id === ruleId && !rule.enabled) {
-        return {
-          ...rule,
-          enabled: true
-        };
-      }
-      return rule;
-    })
-  };
+var enableRule = (ruleId) => machine.assign(({ context }) => {
+	return { rules: context.rules.map((rule) => {
+		if (rule.id === ruleId && !rule.enabled) return {
+			...rule,
+			enabled: true
+		};
+		return rule;
+	}) };
 });
-const addElementRules = (fqn, type) => machine.assign(({ context }) => {
-  return {
-    rules: [
-      ...context.rules,
-      {
-        id: nextId(context, type + fqn),
-        expr: { ref: { model: fqn } },
-        enabled: true,
-        type
-      }
-    ]
-  };
+var addElementRules = (fqn, type) => machine.assign(({ context }) => {
+	return { rules: [...context.rules, {
+		id: nextId(context, type + fqn),
+		expr: { ref: { model: fqn } },
+		enabled: true,
+		type
+	}] };
 });
-const removeElementRules = (fqn) => machine.assign(({ context }) => {
-  const isRule = isRuleOf(fqn);
-  return {
-    rules: context.rules.filter((rule) => {
-      return !isRule(rule);
-    })
-  };
+var removeElementRules = (fqn) => machine.assign(({ context }) => {
+	const isRule = isRuleOf(fqn);
+	return { rules: context.rules.filter((rule) => {
+		return !isRule(rule);
+	}) };
 });
-const toggleElement = () => machine.enqueueActions(({ context, event, enqueue }) => {
-  assertEvent(event, "toggle.element");
-  const isRuleOfTheElement = isRuleOf(event.id);
-  const lastRule = last(context.rules);
-  if (lastRule && isRuleOfTheElement(lastRule)) {
-    enqueue.assign({
-      rules: context.rules.slice(0, -1)
-    });
-    return;
-  }
-  const state = deriveElementState(event.id, context);
-  switch (state.state) {
-    case "disabled": {
-      enqueue(enableRule(state.ruleId));
-      break;
-    }
-    // Include element if it is not in view and not included/excluded by any rule
-    case "not-present": {
-      enqueue(removeElementRules(event.id));
-      enqueue(addElementRules(event.id, "include"));
-      break;
-    }
-    case "include-implicit": {
-      enqueue(removeElementRules(event.id));
-      enqueue(addElementRules(event.id, "exclude"));
-      break;
-    }
-    case "include-explicit":
-    case "exclude": {
-      enqueue(removeElementRules(event.id));
-      break;
-    }
-    default:
-      nonexhaustive(state);
-  }
+var toggleElement = () => machine.enqueueActions(({ context, event, enqueue }) => {
+	assertEvent(event, "toggle.element");
+	const isRuleOfTheElement = isRuleOf(event.id);
+	const lastRule = last(context.rules);
+	if (lastRule && isRuleOfTheElement(lastRule)) {
+		enqueue.assign({ rules: context.rules.slice(0, -1) });
+		return;
+	}
+	const state = deriveElementState(event.id, context);
+	switch (state.state) {
+		case "disabled":
+			enqueue(enableRule(state.ruleId));
+			break;
+		case "not-present":
+			enqueue(removeElementRules(event.id));
+			enqueue(addElementRules(event.id, "include"));
+			break;
+		case "include-implicit":
+			enqueue(removeElementRules(event.id));
+			enqueue(addElementRules(event.id, "exclude"));
+			break;
+		case "include-explicit":
+		case "exclude":
+			enqueue(removeElementRules(event.id));
+			break;
+		default: nonexhaustive$1(state);
+	}
 });
-const toggleRule = () => machine.assign(({ context, event }) => {
-  assertEvent(event, "toggle.rule");
-  return {
-    rules: context.rules.map((rule) => {
-      if (rule.id === event.ruleId) {
-        return {
-          ...rule,
-          enabled: !rule.enabled
-        };
-      }
-      return rule;
-    })
-  };
+var toggleRule = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "toggle.rule");
+	return { rules: context.rules.map((rule) => {
+		if (rule.id === event.ruleId) return {
+			...rule,
+			enabled: !rule.enabled
+		};
+		return rule;
+	}) };
 });
-const deleteRule = () => machine.assign(({ context, event }) => {
-  assertEvent(event, "delete.rule");
-  return {
-    rules: context.rules.filter((rule) => rule.id !== event.ruleId)
-  };
+var deleteRule = () => machine.assign(({ context, event }) => {
+	assertEvent(event, "delete.rule");
+	return { rules: context.rules.filter((rule) => rule.id !== event.ruleId) };
 });
-const scheduleLayout = () => machine.raise({ type: "layout" });
-const idle = machine.createStateConfig({
-  id: "idle",
-  on: {
-    "select.open": {
-      ...to.selecting
-    },
-    "toggle.rule": {
-      actions: toggleRule(),
-      ...to.layouting
-    },
-    "delete.rule": {
-      actions: deleteRule(),
-      ...to.layouting
-    }
-  }
+var scheduleLayout = () => machine.raise({ type: "layout" });
+var idle = machine.createStateConfig({
+	id: "idle",
+	on: {
+		"select.open": { ...to.selecting },
+		"toggle.rule": {
+			actions: toggleRule(),
+			...to.layouting
+		},
+		"delete.rule": {
+			actions: deleteRule(),
+			...to.layouting
+		}
+	}
 });
-const selecting = machine.createStateConfig({
-  id: "selecting",
-  on: {
-    "toggle.element": {
-      actions: [
-        toggleElement(),
-        emitViewUpdate(),
-        scheduleLayout()
-      ]
-      // ...to.layouting,
-    },
-    "select.close": {
-      ...to.idle
-    }
-  }
+var selecting = machine.createStateConfig({
+	id: "selecting",
+	on: {
+		"toggle.element": { actions: [
+			toggleElement(),
+			emitViewUpdate(),
+			scheduleLayout()
+		] },
+		"select.close": { ...to.idle }
+	}
 });
-const layouting = machine.createStateConfig({
-  id: "layouting",
-  always: {
-    actions: scheduleLayout(),
-    ...to.idle
-  }
+var layouting = machine.createStateConfig({
+	id: "layouting",
+	always: {
+		actions: scheduleLayout(),
+		...to.idle
+	}
 });
-const editor = machine.createStateConfig({
-  initial: "selecting",
-  states: {
-    idle,
-    selecting,
-    layouting
-  }
+var editor = machine.createStateConfig({
+	initial: "selecting",
+	states: {
+		idle,
+		selecting,
+		layouting
+	}
 });
-
+//#endregion
 export { editor };

package/dist/adhoc-editor/state/actor.js

@@ -1,16 +1,14 @@
-import { editor } from './actor.editor.js';
-import { layouter } from './actor.layouter.js';
-import { machine, createContext } from './actor.types.js';
-
-const _adhocEditorLogic = machine.createMachine({
-  id: "adhoc-editor",
-  context: createContext,
-  type: "parallel",
-  states: {
-    layouter,
-    editor
-  }
+import { createContext, machine } from "./actor.types.js";
+import { layouter } from "./actor.layouter.js";
+import { editor } from "./actor.editor.js";
+var adhocEditorLogic = machine.createMachine({
+	id: "adhoc-editor",
+	context: createContext,
+	type: "parallel",
+	states: {
+		layouter,
+		editor
+	}
 });
-const adhocEditorLogic = _adhocEditorLogic;
-
+//#endregion
 export { adhocEditorLogic };

package/dist/adhoc-editor/state/actor.layouter.js

@@ -1,70 +1,54 @@
-import { objectHash } from '@likec4/core/utils';
-import { piped, filter, map } from 'remeda';
-import { log, assign, emit } from 'xstate';
-import { machine, ruleToPredicate } from './actor.types.js';
-
-const to = {
-  idle: { target: "#layouter-idle" },
-  call: { target: "#layouter-call" }
+import "../../_virtual/_rolldown/runtime.js";
+import { machine, ruleToPredicate } from "./actor.types.js";
+import { filter, map, piped } from "remeda";
+import { objectHash } from "@likec4/core/utils";
+import { assign, emit, log } from "xstate";
+//#region src/adhoc-editor/state/actor.layouter.ts
+var to = {
+	idle: { target: "#layouter-idle" },
+	call: { target: "#layouter-call" }
 };
-const idle = machine.createStateConfig({
-  id: to.idle.target.substring(1),
-  entry: log("entry idle ->"),
-  exit: log(" -> idle exit "),
-  on: {
-    "layout": {
-      ...to.call
-    }
-  }
+var idle = machine.createStateConfig({
+	id: to.idle.target.substring(1),
+	entry: log("entry idle ->"),
+	exit: log(" -> idle exit "),
+	on: { "layout": { ...to.call } }
 });
-const emitViewUpdate = () => machine.emit({ type: "view.update" });
-const selectEnabled = piped(
-  filter((rule) => rule.enabled),
-  map(ruleToPredicate)
-);
-const call = machine.createStateConfig({
-  id: to.call.target.substring(1),
-  entry: log("entry call ->"),
-  exit: log(" -> call exit "),
-  invoke: {
-    src: "service",
-    input: ({ context }) => ({
-      predicates: selectEnabled(context.rules)
-    }),
-    onDone: {
-      actions: [
-        assign({
-          view: ({ context, event }) => {
-            const id = objectHash(selectEnabled(context.rules));
-            return {
-              ...event.output.view,
-              hash: id,
-              id
-            };
-          },
-          error: void 0
-        }),
-        emit({ type: "view.update" })
-      ],
-      ...to.idle
-    },
-    onError: {
-      actions: [
-        log(({ event }) => `error: ${event.error}`),
-        assign({
-          error: ({ event }) => `${event.error}`
-        })
-      ],
-      ...to.idle
-    }
-  }
+var emitViewUpdate = () => machine.emit({ type: "view.update" });
+var selectEnabled = piped(filter((rule) => rule.enabled), map(ruleToPredicate));
+var call = machine.createStateConfig({
+	id: to.call.target.substring(1),
+	entry: log("entry call ->"),
+	exit: log(" -> call exit "),
+	invoke: {
+		src: "service",
+		input: ({ context }) => ({ predicates: selectEnabled(context.rules) }),
+		onDone: {
+			actions: [assign({
+				view: ({ context, event }) => {
+					const id = objectHash(selectEnabled(context.rules));
+					return {
+						...event.output.view,
+						hash: id,
+						id
+					};
+				},
+				error: void 0
+			}), emit({ type: "view.update" })],
+			...to.idle
+		},
+		onError: {
+			actions: [log(({ event }) => `error: ${event.error}`), assign({ error: ({ event }) => `${event.error}` })],
+			...to.idle
+		}
+	}
 });
-const layouter = machine.createStateConfig({
-  initial: "idle",
-  states: {
-    idle,
-    call
-  }
+var layouter = machine.createStateConfig({
+	initial: "idle",
+	states: {
+		idle,
+		call
+	}
 });
-
+//#endregion
 export { emitViewUpdate, layouter };

package/dist/adhoc-editor/state/actor.types.js

@@ -1,29 +1,25 @@
-import { setup } from 'xstate';
-
+import "../../_virtual/_rolldown/runtime.js";
+import { setup } from "xstate";
+//#region src/adhoc-editor/state/actor.types.ts
 function ruleToPredicate(rule) {
-  return rule.type === "include" ? { include: [rule.expr] } : { exclude: [rule.expr] };
+	return rule.type === "include" ? { include: [rule.expr] } : { exclude: [rule.expr] };
 }
-const machine = setup({
-  types: {
-    context: {},
-    tags: "",
-    // input: {} as Input,
-    events: {},
-    emitted: {}
-  },
-  actors: {
-    service: {}
-  },
-  guards: {
-    hasView: ({ context }) => context.view !== null
-  }
+var machine = setup({
+	types: {
+		context: {},
+		tags: "",
+		events: {},
+		emitted: {}
+	},
+	actors: { service: {} },
+	guards: { hasView: ({ context }) => context.view !== null }
 });
 function createContext() {
-  return {
-    view: null,
-    error: void 0,
-    rules: []
-  };
+	return {
+		view: null,
+		error: void 0,
+		rules: []
+	};
 }
-
+//#endregion
 export { createContext, machine, ruleToPredicate };