@likec4/diagram 1.57.0 → 1.59.0

package/dist/adhoc-editor/state/actor.d.ts

@@ -1,13 +0,0 @@
-import { ActorRef, SnapshotFrom, StateMachine } from 'xstate';
-import { editor } from './actor.editor';
-import { layouter } from './actor.layouter';
-import { Context, EmittedEvents, Events } from './actor.types';
-export interface AdhocEditorLogic extends StateMachine<Context, Events, any, any, any, any, any, {
-    layouter: keyof typeof layouter['states'];
-    editor: keyof typeof editor['states'];
-}, any, any, EmittedEvents, any, any, any> {
-}
-export declare const adhocEditorLogic: AdhocEditorLogic;
-export type AdhocEditorSnapshot = SnapshotFrom<AdhocEditorLogic>;
-export interface AdhocEditorActorRef extends ActorRef<AdhocEditorSnapshot, Events, EmittedEvents> {
-}

package/dist/adhoc-editor/state/actor.editor.d.ts

@@ -1,56 +0,0 @@
-import { Context, Events, AdhocViewServiceActor, EmittedEvents } from './actor.types';
-import { ActionFunction } from 'xstate';
-export declare const editor: {
-    initial: string;
-    states: {
-        idle: {
-            id: string;
-            on: {
-                'select.open': {
-                    target: "#selecting";
-                };
-                'toggle.rule': {
-                    target: "#layouting";
-                    actions: ActionFunction<Context, Events, Events, undefined, {
-                        src: "service";
-                        logic: AdhocViewServiceActor;
-                        id: string | undefined;
-                    }, never, never, never, never>;
-                };
-                'delete.rule': {
-                    target: "#layouting";
-                    actions: ActionFunction<Context, Events, Events, undefined, {
-                        src: "service";
-                        logic: AdhocViewServiceActor;
-                        id: string | undefined;
-                    }, never, never, never, never>;
-                };
-            };
-        };
-        selecting: {
-            id: string;
-            on: {
-                'toggle.element': {
-                    actions: ActionFunction<Context, Events, Events, undefined, {
-                        src: "service";
-                        logic: AdhocViewServiceActor;
-                        id: string | undefined;
-                    }, never, {
-                        type: "hasView";
-                        params: unknown;
-                    }, never, EmittedEvents>[];
-                };
-                'select.close': {
-                    target: "#idle";
-                };
-            };
-        };
-        layouting: {
-            id: string;
-            always: {
-                target: "#idle";
-                actions: ActionFunction<Context, Events, Events, undefined, never, never, never, never, never>;
-            };
-        };
-    };
-};

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

@@ -1,167 +0,0 @@
-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);
-}
-var isRuleOf = (fqn) => (rule) => {
-	return 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;
-};
-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$1(isIncludedInView === false, "Element not in view should not be included or excluded by any rule");
-			return {
-				state: "not-present",
-				ruleId: void 0
-			};
-	}
-}
-var enableRule = (ruleId) => machine.assign(({ context }) => {
-	return { rules: context.rules.map((rule) => {
-		if (rule.id === ruleId && !rule.enabled) return {
-			...rule,
-			enabled: true
-		};
-		return rule;
-	}) };
-});
-var addElementRules = (fqn, type) => machine.assign(({ context }) => {
-	return { rules: [...context.rules, {
-		id: nextId(context, type + fqn),
-		expr: { ref: { model: fqn } },
-		enabled: true,
-		type
-	}] };
-});
-var removeElementRules = (fqn) => machine.assign(({ context }) => {
-	const isRule = isRuleOf(fqn);
-	return { rules: context.rules.filter((rule) => {
-		return !isRule(rule);
-	}) };
-});
-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);
-	}
-});
-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;
-	}) };
-});
-var deleteRule = () => machine.assign(({ context, event }) => {
-	assertEvent(event, "delete.rule");
-	return { rules: context.rules.filter((rule) => rule.id !== event.ruleId) };
-});
-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
-		}
-	}
-});
-var selecting = machine.createStateConfig({
-	id: "selecting",
-	on: {
-		"toggle.element": { actions: [
-			toggleElement(),
-			emitViewUpdate(),
-			scheduleLayout()
-		] },
-		"select.close": { ...to.idle }
-	}
-});
-var layouting = machine.createStateConfig({
-	id: "layouting",
-	always: {
-		actions: scheduleLayout(),
-		...to.idle
-	}
-});
-var editor = machine.createStateConfig({
-	initial: "selecting",
-	states: {
-		idle,
-		selecting,
-		layouting
-	}
-});
-//#endregion
-export { editor };

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

@@ -1,14 +0,0 @@
-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
-	}
-});
-//#endregion
-export { adhocEditorLogic };

package/dist/adhoc-editor/state/actor.layouter.d.ts

@@ -1,51 +0,0 @@
-import { ActionFunction, LogAction, ActorRef, MachineSnapshot, AnyActorRef, StateValue, AnyEventObject, DoneActorEvent, ErrorActorEvent } from 'xstate';
-import { Context, Events, EmittedEvents, AdhocViewServiceActor } from './actor.types';
-import { AdhocViewPredicate } from '@likec4/core/compute-view';
-import { LayoutedElementView } from '@likec4/core';
-export declare const emitViewUpdate: () => ActionFunction<Context, Events, Events, undefined, never, never, never, never, EmittedEvents>;
-export declare const layouter: {
-    initial: string;
-    states: {
-        idle: {
-            id: string;
-            entry: LogAction<Context, Events, undefined, Events>;
-            exit: LogAction<Context, Events, undefined, Events>;
-            on: {
-                layout: {
-                    target: "#layouter-call";
-                };
-            };
-        };
-        call: {
-            id: string;
-            entry: LogAction<Context, Events, undefined, Events>;
-            exit: LogAction<Context, Events, undefined, Events>;
-            invoke: {
-                src: "service";
-                input: ({ context }: {
-                    context: Context;
-                    event: Events;
-                    self: ActorRef<MachineSnapshot<Context, Events, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, Events, AnyEventObject>;
-                }) => {
-                    predicates: AdhocViewPredicate[];
-                };
-                onDone: {
-                    target: "#layouter-idle";
-                    actions: ( ActionFunction<Context, DoneActorEvent<{
-                        view: LayoutedElementView;
-                    }, string>, Events, undefined, {
-                        src: "service";
-                        logic: AdhocViewServiceActor;
-                        id: string | undefined;
-                    }, never, never, never, never> | ActionFunction<Context, DoneActorEvent<{
-                        view: LayoutedElementView;
-                    }, string>, Events, undefined, never, never, never, never, EmittedEvents>)[];
-                };
-                onError: {
-                    target: "#layouter-idle";
-                    actions: LogAction<Context, ErrorActorEvent<unknown, string>, undefined, Events>[];
-                };
-            };
-        };
-    };
-};

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

@@ -1,54 +0,0 @@
-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" }
-};
-var idle = machine.createStateConfig({
-	id: to.idle.target.substring(1),
-	entry: log("entry idle ->"),
-	exit: log(" -> idle exit "),
-	on: { "layout": { ...to.call } }
-});
-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
-		}
-	}
-});
-var layouter = machine.createStateConfig({
-	initial: "idle",
-	states: {
-		idle,
-		call
-	}
-});
-//#endregion
-export { emitViewUpdate, layouter };

package/dist/adhoc-editor/state/actor.types.d.ts

@@ -1,63 +0,0 @@
-import { AdhocViewPredicate } from '@likec4/core/compute-view';
-import { Fqn, LayoutedElementView, ModelFqnExpr } from '@likec4/core/types';
-import { PromiseActorLogic } from 'xstate/actors';
-import { SetupReturn, NonReducibleUnknown, MetaObject } from 'xstate';
-type CalcAdhocViewInput = {
-    predicates: AdhocViewPredicate[];
-};
-type CalcAdhocViewOutput = {
-    view: LayoutedElementView;
-};
-export type AdhocViewService = {
-    process: (input: CalcAdhocViewInput) => Promise<CalcAdhocViewOutput>;
-};
-export type AdhocViewServiceActor = PromiseActorLogic<CalcAdhocViewOutput, CalcAdhocViewInput>;
-export type Input = {};
-export type AdhocRule = {
-    id: string;
-    expr: ModelFqnExpr.Ref;
-    enabled: boolean;
-    type: 'include' | 'exclude';
-};
-export declare function ruleToPredicate(rule: AdhocRule): AdhocViewPredicate;
-export interface Context {
-    view: LayoutedElementView | null;
-    error: string | undefined;
-    rules: AdhocRule[];
-}
-export type EmittedEvents = {
-    type: 'navigate.to';
-} | {
-    type: 'view.update';
-} | {
-    type: 'click.element';
-    id: Fqn;
-};
-export type Events = {
-    type: 'toggle.element';
-    id: Fqn;
-} | {
-    type: 'click.element';
-    id: Fqn;
-} | {
-    type: 'toggle.rule';
-    ruleId: string;
-} | {
-    type: 'delete.rule';
-    ruleId: string;
-} | {
-    type: 'select.open';
-} | {
-    type: 'select.close';
-} | {
-    type: 'layout';
-} | {
-    type: 'dispose';
-};
-export declare const machine: SetupReturn<Context, Events, {
-    service: AdhocViewServiceActor;
-}, {}, {}, {
-    hasView: unknown;
-}, never, "hasView", NonReducibleUnknown, NonReducibleUnknown, EmittedEvents, MetaObject>;
-export declare function createContext(): Context;
-export {};

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

@@ -1,25 +0,0 @@
-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] };
-}
-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: []
-	};
-}
-//#endregion
-export { createContext, machine, ruleToPredicate };

package/dist/adhoc-editor/state/panel.d.ts

@@ -1,95 +0,0 @@
-import { Fqn } from '@likec4/core';
-import { StoreSnapshot, Store } from '@xstate/store';
-import { TreeCollection } from '@zag-js/collection';
-import { PropsWithChildren } from 'react';
-import { TreeNodeData } from '../useElementsTree';
-type EditorPanelState = {
-    searchInput: string;
-    expandedValue: string[];
-    collection: TreeCollection<TreeNodeData>;
-};
-declare const createEditorPanelStore: ({ initial, sideEffects, }: {
-    initial: TreeCollection<TreeNodeData>;
-    sideEffects: {
-        onElementStateClick: (payload: {
-            id: Fqn;
-        }) => void;
-    };
-}) => Store<EditorPanelState, {
-    inputChange: {
-        value: string;
-    };
-    inputKeyDown: {};
-    modelUpdate: {
-        collection: TreeCollection<TreeNodeData>;
-    };
-    elementClick: {
-        id: Fqn;
-    };
-}, {
-    type: "inputKeyDown";
-}>;
-export type EditorPanelStore = ReturnType<typeof createEditorPanelStore>;
-export declare const EditorPanelStoreProvider: (props: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
-export declare function selectEditorPanelState<T>(selector: (state: EditorPanelState) => T): [
-    selector: (snapshot: StoreSnapshot<EditorPanelState>) => T,
-    compare: (a: NoInfer<T> | undefined, b: NoInfer<T>) => boolean
-];
-export declare function selectEditorPanelState<T>(selector: (state: EditorPanelState) => T, compare: (a: NoInfer<T> | undefined, b: NoInfer<T>) => boolean): [
-    selector: (snapshot: StoreSnapshot<EditorPanelState>) => T,
-    compare: (a: NoInfer<T> | undefined, b: NoInfer<T>) => boolean
-];
-export declare function useEditorPanelStore(): Store<EditorPanelState, {
-    inputChange: {
-        value: string;
-    };
-    inputKeyDown: {};
-    modelUpdate: {
-        collection: TreeCollection<TreeNodeData>;
-    };
-    elementClick: {
-        id: Fqn;
-    };
-}, {
-    type: "inputKeyDown";
-}>;
-export declare function useEditorPanelState<T>(arg1: readonly [
-    (snapshot: StoreSnapshot<EditorPanelState>) => T,
-    (a: NoInfer<T> | undefined, b: NoInfer<T>) => boolean
-]): T;
-export declare function useEditorPanelState<T>(selector: (snapshot: StoreSnapshot<EditorPanelState>) => T, compare?: (a: NoInfer<T> | undefined, b: NoInfer<T>) => boolean): T;
-/**
- * Hook to subscribe to editor panel events
- * @param args - The event name and handler function
- * @example
- * useOnEditorPanelEvent('inputKeyDown', () => {
- *   console.log('Input key down event')
- * })
- */
-export declare function useOnEditorPanelEvent(...args: Parameters<EditorPanelStore['on']>): void;
-/**
- * Hook to access the editor panel store trigger or create a wrapped trigger function
- *
- * @overload
- * @returns The store trigger object
- *
- * @overload
- * @template T - The parameter types for the wrapped trigger function
- * @param trigger - A function that receives the store trigger as the first parameter
- * @returns A wrapped function that calls the trigger with the store trigger prepended
- *
- * @example
- * // Get the trigger object directly
- * const trigger = useEditorPanelTrigger()
- * trigger.inputChange({ value: 'search' })
- *
- * @example
- * // Create a wrapped trigger function
- * const handleInputChange = useEditorPanelTrigger((trigger, value: string) => {
- *   trigger.inputChange({ value })
- * })
- * handleInputChange('search')
- */
-export declare function useEditorPanelTrigger(): EditorPanelStore['trigger'];
-export declare function useEditorPanelTrigger<T extends any[]>(trigger: (...params: [trigger: EditorPanelStore['trigger'], ...T]) => void): (...args: T) => void;
-export {};

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

@@ -1,124 +0,0 @@
-import "../../_virtual/_rolldown/runtime.js";
-import { useCallbackRef } from "../../hooks/useCallbackRef.js";
-import { useUpdateEffect } from "../../hooks/useUpdateEffect.js";
-import { useLikeC4Model } from "../../hooks/useLikeC4Model.js";
-import { useAdhocEditorActor } from "../hooks.js";
-import { createTreeCollection } from "../useElementsTree.js";
-import { deriveElementStates } from "./utils.js";
-import { createContext, useContext, useEffect, useMemo, useRef } from "react";
-import { jsx } from "react/jsx-runtime";
-import { hasAtLeast } from "remeda";
-import { createStore, shallowEqual } from "@xstate/store";
-import { useSelector } from "@xstate/store/react";
-//#region src/adhoc-editor/state/panel.tsx
-var createEditorPanelStore = ({ initial, sideEffects }) => createStore({
-	context: {
-		searchInput: "",
-		expandedValue: [],
-		collection: initial
-	},
-	emits: { inputKeyDown: (payload) => {} },
-	on: {
-		"inputChange": (context, event) => {
-			return {
-				...context,
-				searchInput: event.value
-			};
-		},
-		"inputKeyDown": (context, event, enqueue) => {
-			enqueue.emit.inputKeyDown();
-		},
-		"modelUpdate": (context, event) => {
-			return {
-				...context,
-				collection: event.collection
-			};
-		},
-		"elementClick": (context, event, enqueue) => {
-			const current = context.collection.findNode(event.id);
-			const path = context.collection.getIndexPath(event.id);
-			if (!current || !path) return context;
-			enqueue.effect(() => {
-				sideEffects.onElementStateClick({ id: event.id });
-			});
-			return context;
-		}
-	}
-});
-var EditorPanelStoreContext = createContext(null);
-var EditorPanelStoreProvider = (props) => {
-	const likec4model = useLikeC4Model();
-	const likec4modelRef = useRef(likec4model);
-	likec4modelRef.current = likec4model;
-	const actorRef = useAdhocEditorActor();
-	const store = useMemo(() => createEditorPanelStore({
-		initial: createTreeCollection(likec4model),
-		sideEffects: { onElementStateClick({ id }) {
-			actorRef.send({
-				type: "toggle.element",
-				id
-			});
-		} }
-	}), [actorRef]);
-	useUpdateEffect(() => {
-		store.trigger.modelUpdate({ collection: createTreeCollection(likec4model, deriveElementStates(actorRef.getSnapshot().context)) });
-	}, [likec4model]);
-	useEffect(() => {
-		const subscription = actorRef.on("view.update", () => {
-			store.trigger.modelUpdate({ collection: createTreeCollection(likec4modelRef.current, deriveElementStates(actorRef.getSnapshot().context)) });
-		});
-		return () => {
-			subscription.unsubscribe();
-		};
-	}, [actorRef]);
-	return /* @__PURE__ */ jsx(EditorPanelStoreContext.Provider, {
-		value: store,
-		children: props.children
-	});
-};
-function selectEditorPanelState(selector, compare) {
-	return [(snapshot) => selector(snapshot.context), compare ?? shallowEqual];
-}
-function useEditorPanelStore() {
-	return useContext(EditorPanelStoreContext);
-}
-function useEditorPanelState(...args) {
-	const store = useEditorPanelStore();
-	let selector;
-	let compare;
-	if (args.length === 2) [selector, compare] = args;
-	else if (args.length === 1 && Array.isArray(args[0]) && hasAtLeast(args[0], 2)) [selector, compare] = args[0];
-	else if (args.length === 1 && Array.isArray(args[0]) && hasAtLeast(args[0], 1)) [selector, compare] = [args[0], shallowEqual];
-	else if (args.length === 1 && typeof args[0] === "function") [selector, compare] = [args[0], shallowEqual];
-	else throw new Error("Invalid arguments for useEditorPanelState");
-	return useSelector(store, selector, compare);
-}
-/**
-* Hook to subscribe to editor panel events
-* @param args - The event name and handler function
-* @example
-* useOnEditorPanelEvent('inputKeyDown', () => {
-*   console.log('Input key down event')
-* })
-*/
-function useOnEditorPanelEvent(...args) {
-	const store = useEditorPanelStore();
-	const event = args[0];
-	const handler = useCallbackRef(args[1]);
-	useEffect(() => {
-		const subscription = store.on(event, handler);
-		return () => {
-			subscription.unsubscribe();
-		};
-	}, [event, store]);
-}
-function useEditorPanelTrigger(...args) {
-	const store = useEditorPanelStore();
-	if (args.length === 0) return store.trigger;
-	const trigger = args[0];
-	return useCallbackRef((...args) => {
-		trigger(...[store.trigger, ...args]);
-	});
-}
-//#endregion
-export { EditorPanelStoreProvider, selectEditorPanelState, useEditorPanelState, useEditorPanelTrigger, useOnEditorPanelEvent };

package/dist/adhoc-editor/state/utils.d.ts

@@ -1,17 +0,0 @@
-import { Fqn } from '@likec4/core/types';
-import { Context } from './actor.types';
-/**
- * Derives the state of elements in the view based on the active rules.
- *
- * Categorizes elements into:
- * - Explicitly included: Elements that are both in the view and have an enabled include rule
- * - Implicitly included: Elements in the view without an explicit include rule
- * - Excluded: Elements with an enabled exclude rule that are not in the view
- */
-export declare function deriveElementStates({ rules, view }: Pick<Context, 'rules' | 'view'>): {
-    includedExplicit: Set<Fqn>;
-    includedImplicit: Set<Fqn>;
-    excluded: Set<Fqn>;
-    disabled: Set<Fqn>;
-};
-export type ElementStates = ReturnType<typeof deriveElementStates>;