@likec4/diagram 1.56.0 → 1.58.0

package/dist/bundle/index.d.ts

@@ -1 +0,0 @@
-export * from '../index';

package/dist/editor/editorActor.actions.d.ts

@@ -1,153 +0,0 @@
-import { ViewChange } from '@likec4/core/types';
-import { ActionFunction, CancelAction, PromiseActorLogic, EventObject, NonReducibleUnknown, StopAction } from 'xstate';
-import { EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './editorActor.setup';
-import { HotkeyActorLogic } from './hotkeyActor';
-export declare const raiseSync: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "waitBeforeSync", never>;
-export declare const cancelSync: () => CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
-export declare const reschedule: (delay?: number) => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "waitBeforeSync", never>;
-type LayoutChanges = ViewChange.ResetManualLayout | ViewChange.SaveViewSnapshot;
-export declare const isLayoutChange: (change: ViewChange) => change is LayoutChanges;
-export declare const withoutSnapshotChanges: (data: ViewChange[]) => (ViewChange.ChangeElementStyle | ViewChange.ChangeAutoLayout)[];
-export declare const saveStateBeforeEdit: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, never, never, never>;
-export declare const startEditing: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, {
-    type: "has pending";
-    params: unknown;
-} | {
-    type: "can undo";
-    params: unknown;
-}, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
-export declare const stopHotkey: () => StopAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
-export declare const ensureHotKey: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, {
-    type: "has pending";
-    params: unknown;
-} | {
-    type: "can undo";
-    params: unknown;
-}, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
-export declare const pushHistory: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, never, never, never>;
-export declare const stopEditing: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, {
-    type: "has pending";
-    params: unknown;
-} | {
-    type: "can undo";
-    params: unknown;
-}, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
-export declare const markHistoryAsSynched: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, never, never, never>;
-export declare const popHistory: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, never, never, never>;
-export declare const undo: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, {
-    type: "has pending";
-    params: unknown;
-} | {
-    type: "can undo";
-    params: unknown;
-}, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
-export declare const addSnapshotToPendingChanges: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
-    src: "hotkey";
-    logic: HotkeyActorLogic;
-    id: "hotkey";
-} | {
-    src: "applyLatest";
-    logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    id: string | undefined;
-} | {
-    src: "executeChange";
-    logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
-    id: string | undefined;
-}, never, never, never, never>;
-export {};

package/dist/editor/editorActor.actions.js

@@ -1,133 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { createViewChange } from "../likec4diagram/state/createViewChange.js";
-import { machine } from "./editorActor.setup.js";
-import { filter, isNot, last, omit } from "remeda";
-//#region src/editor/editorActor.actions.ts
-/**
-* Actually this is DiagramActorRef
-* But we can't use it here due to circular type inference
-*/
-var diagramActorRef = (system) => {
-	return system.get("diagram");
-};
-/**
-* Actually this is DiagramActorRef
-* But we can't use it here due to circular type inference
-*/
-var getDiagramContext = function(system) {
-	return system.get("diagram").getSnapshot().context;
-};
-var raiseSync = () => machine.raise({ type: "sync" }, {
-	delay: 200,
-	id: "sync"
-});
-var cancelSync = () => machine.cancel("sync");
-var reschedule = (delay = 350) => machine.raise(({ event }) => event, { delay });
-var isLayoutChange = (change) => change.op === "reset-manual-layout" || change.op === "save-view-snapshot";
-var withoutSnapshotChanges = filter(isNot(isLayoutChange));
-var saveStateBeforeEdit = () => machine.assign(({ system }) => {
-	const parentContext = getDiagramContext(system);
-	return { beforeEditing: {
-		xynodes: parentContext.xynodes.map(({ measured, data, ...n }) => ({
-			...omit(n, [
-				"selected",
-				"dragging",
-				"resizing"
-			]),
-			data: omit(data, ["dimmed", "hovered"]),
-			measured,
-			initialWidth: measured?.width ?? n.width ?? n.initialWidth,
-			initialHeight: measured?.height ?? n.height ?? n.initialHeight
-		})),
-		xyedges: parentContext.xyedges.map(({ data, ...e }) => ({
-			...omit(e, ["selected"]),
-			data: omit(data, [
-				"active",
-				"dimmed",
-				"hovered"
-			])
-		})),
-		change: createViewChange(parentContext),
-		view: parentContext.view,
-		synched: false
-	} };
-});
-var startEditing = () => machine.enqueueActions(({ enqueue, event }) => {
-	enqueue(saveStateBeforeEdit());
-	if (event.type === "edit.start") enqueue.assign({ editing: event.subject });
-});
-var stopHotkey = () => machine.stopChild("hotkey");
-var ensureHotKey = () => machine.enqueueActions(({ check, enqueue, self }) => {
-	const hasUndo = check("can undo");
-	const hotkey = self.getSnapshot().children["hotkey"];
-	if (!hasUndo && hotkey) {
-		enqueue.stopChild(hotkey);
-		return;
-	}
-	if (hasUndo && !hotkey) enqueue.spawnChild("hotkey", { id: "hotkey" });
-});
-var pushHistory = () => machine.assign(({ context }) => {
-	const snapshot = context.beforeEditing;
-	if (!snapshot) return { editing: null };
-	const history = [...context.history, snapshot];
-	if (history.length > 50) history.shift();
-	return {
-		beforeEditing: null,
-		editing: null,
-		history
-	};
-});
-var stopEditing = () => machine.enqueueActions(({ event, enqueue }) => {
-	if (event.type === "edit.finish" && event.wasChanged) {
-		enqueue(pushHistory());
-		enqueue(raiseSync());
-		return;
-	}
-	enqueue.assign({
-		beforeEditing: null,
-		editing: null
-	});
-});
-var markHistoryAsSynched = () => machine.assign(({ context }) => {
-	return {
-		beforeEditing: context.beforeEditing && context.beforeEditing.synched === false ? {
-			...context.beforeEditing,
-			synched: true
-		} : context.beforeEditing,
-		history: context.history.map((i) => ({
-			...i,
-			synched: true
-		}))
-	};
-});
-var popHistory = () => machine.assign(({ context }) => {
-	if (context.history.length <= 1) return { history: [] };
-	return { history: context.history.slice(0, context.history.length - 1) };
-});
-var undo = () => machine.enqueueActions(({ context, enqueue, system }) => {
-	const lastHistoryItem = last(context.history);
-	if (!lastHistoryItem) return;
-	enqueue(cancelSync());
-	enqueue(popHistory());
-	enqueue(ensureHotKey());
-	const diagramActor = diagramActorRef(system);
-	enqueue.sendTo(diagramActor, {
-		type: "update.view",
-		view: lastHistoryItem.view,
-		xyedges: lastHistoryItem.xyedges,
-		xynodes: lastHistoryItem.xynodes,
-		source: "editor"
-	});
-	enqueue.assign({ pendingChanges: [] });
-	if (lastHistoryItem.synched) enqueue.raise({
-		type: "change",
-		change: lastHistoryItem.change
-	}, { delay: 50 });
-	else enqueue(raiseSync());
-});
-var addSnapshotToPendingChanges = () => machine.assign(({ context, system }) => {
-	const change = createViewChange(getDiagramContext(system));
-	return { pendingChanges: [...withoutSnapshotChanges(context.pendingChanges), change] };
-});
-//#endregion
-export { addSnapshotToPendingChanges, cancelSync, ensureHotKey, isLayoutChange, markHistoryAsSynched, pushHistory, reschedule, saveStateBeforeEdit, startEditing, stopEditing, stopHotkey, undo, withoutSnapshotChanges };

package/dist/editor/editorActor.setup.d.ts

@@ -1,84 +0,0 @@
-import { NonReducibleUnknown, SetupReturn, PromiseActorLogic, EventObject, MetaObject } from 'xstate';
-import { Types } from '../likec4diagram/types';
-import { HotKeyEvent, HotkeyActorLogic } from './hotkeyActor';
-import type * as t from '@likec4/core/types';
-export declare namespace EditorCalls {
-    type ApplyLatestToManual = (params: {
-        input: ApplyLatestToManual.Input;
-    }) => Promise<ApplyLatestToManual.Output>;
-    namespace ApplyLatestToManual {
-        type Input = {
-            viewId: t.ViewId;
-            current: t.LayoutedView | undefined;
-        };
-        type Output = {
-            updated: t.LayoutedView;
-        };
-    }
-    type ExecuteChange = (params: {
-        input: ExecuteChange.Input;
-    }) => Promise<ExecuteChange.Output>;
-    namespace ExecuteChange {
-        type Input = {
-            viewId: t.ViewId;
-            changes: t.ViewChange[];
-        };
-        type Output = NonReducibleUnknown;
-    }
-}
-export type EditorActorEvent = {
-    type: 'sync';
-} | {
-    type: 'change';
-    change: t.ViewChange;
-} | {
-    type: 'edit.start';
-    subject: 'node' | 'edge';
-} | {
-    type: 'edit.finish';
-    wasChanged?: boolean;
-} | {
-    type: 'applyLatestToManual';
-} | {
-    type: 'synced';
-} | {
-    type: 'cancel';
-} | {
-    type: 'reset';
-} | HotKeyEvent;
-export type HistorySnapshot = {
-    view: t.LayoutedView;
-    change: t.ViewChange.SaveViewSnapshot;
-    xynodes: Types.Node[];
-    xyedges: Types.Edge[];
-    synched: boolean;
-};
-export interface EditorActorInput {
-    viewId: t.ViewId;
-}
-export interface EditorActorContext {
-    viewId: t.ViewId;
-    pendingChanges: t.ViewChange[];
-    history: ReadonlyArray<HistorySnapshot>;
-    /**
-     * The state before editing started
-     */
-    beforeEditing: HistorySnapshot | null;
-    /**
-     * The subject of the edit
-     */
-    editing: 'node' | 'edge' | null;
-}
-export type EditorActorEmitedEvent = {
-    type: 'idle';
-};
-export declare const machine: SetupReturn<EditorActorContext, EditorActorEvent, {
-    applyLatest: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    executeChange: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
-    hotkey: HotkeyActorLogic;
-}, {
-    hotkey: "hotkey";
-}, {}, {
-    'has pending': unknown;
-    'can undo': unknown;
-}, "500ms" | "waitBeforeSync", "pending", EditorActorInput, NonReducibleUnknown, EditorActorEmitedEvent, MetaObject>;

package/dist/editor/editorActor.states.js

@@ -1,219 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { machine } from "./editorActor.setup.js";
-import { addSnapshotToPendingChanges, cancelSync, ensureHotKey, isLayoutChange, markHistoryAsSynched, pushHistory, reschedule, saveStateBeforeEdit, startEditing, stopEditing, stopHotkey, undo, withoutSnapshotChanges } from "./editorActor.actions.js";
-import { find } from "remeda";
-import { assign, enqueueActions, log, sendTo } from "xstate";
-//#region src/editor/editorActor.states.ts
-/**
-* Actually this is DiagramActorRef
-* But we can't use it here due to circular type inference
-*/
-var diagramActorRef = function(params) {
-	return params.system.get("diagram");
-};
-var to = {
-	idle: { target: "#idle" },
-	editing: { target: "#editing" },
-	afterEdit: { target: "#afterEdit" },
-	pending: { target: "#pending" },
-	applyLatestToManual: { target: "#applyLatestToManual" },
-	executeChanges: { target: "#executeChanges" }
-};
-/**
-* Idle state, no pending operations
-*/
-var idle = machine.createStateConfig({
-	id: "idle",
-	on: {
-		"sync": { ...to.pending },
-		"edit.start": { ...to.editing }
-	}
-});
-/**
-* Edit state, some operation is in progress, come to this state from idle
-*/
-var editing = machine.createStateConfig({
-	id: "editing",
-	tags: "pending",
-	entry: [startEditing(), cancelSync()],
-	on: {
-		change: {
-			actions: stopEditing(),
-			...to.executeChanges
-		},
-		"edit.finish": {
-			actions: stopEditing(),
-			...to.afterEdit
-		},
-		"undo": {
-			actions: stopEditing(),
-			...to.idle
-		}
-	}
-});
-/**
-* Syncing state, some edits are not yet synced
-*/
-var pending = machine.createStateConfig({
-	id: "pending",
-	tags: ["pending"],
-	entry: ensureHotKey(),
-	on: {
-		"sync": {
-			reenter: true,
-			...to.pending
-		},
-		"edit.start": {
-			actions: [addSnapshotToPendingChanges()],
-			...to.editing
-		}
-	},
-	after: { "waitBeforeSync": {
-		actions: [addSnapshotToPendingChanges()],
-		...to.executeChanges
-	} }
-});
-/**
-* Decide where to go next
-*/
-var afterEdit = machine.createStateConfig({
-	id: "afterEdit",
-	always: [{
-		guard: "has pending",
-		...to.pending
-	}, { ...to.idle }]
-});
-/**
-* Syncing state, some edits are not yet synced
-*/
-var applyLatestToManual = machine.createStateConfig({
-	id: "applyLatestToManual",
-	entry: [cancelSync(), saveStateBeforeEdit()],
-	initial: "call",
-	states: {
-		call: { invoke: {
-			src: "applyLatest",
-			input: ({ context }) => {
-				const current = context.beforeEditing?.change.layout;
-				return {
-					current: current && current._layout === "manual" ? current : void 0,
-					viewId: context.viewId
-				};
-			},
-			onDone: {
-				actions: sendTo(diagramActorRef, ({ event }) => ({
-					type: "update.view",
-					view: event.output.updated
-				}), { delay: 10 }),
-				target: "wait"
-			},
-			onError: {
-				actions: [assign({
-					beforeEditing: null,
-					pendingChanges: []
-				}), ({ event }) => {
-					console.error(event.error);
-				}],
-				...to.idle
-			}
-		} },
-		wait: {
-			entry: pushHistory(),
-			on: { "*": { actions: [log(({ event }) => `wait received unexpected event: ${event.type}`), reschedule(500)] } },
-			after: { "500ms": {
-				actions: [addSnapshotToPendingChanges(), ensureHotKey()],
-				...to.executeChanges
-			} }
-		}
-	}
-});
-/**
-* Calls `executeChange` to save the snapshot
-*/
-var executeChanges = machine.createStateConfig({
-	id: "executeChanges",
-	entry: [assign(({ event, context }) => {
-		if (event.type === "change") {
-			if (isLayoutChange(event.change)) return { pendingChanges: [...withoutSnapshotChanges(context.pendingChanges), event.change] };
-			if (!context.pendingChanges.includes(event.change)) return { pendingChanges: [...context.pendingChanges, event.change] };
-		}
-		return {};
-	}), cancelSync()],
-	invoke: {
-		src: "executeChange",
-		input: ({ context }) => ({
-			changes: context.pendingChanges,
-			viewId: context.viewId
-		}),
-		onDone: {
-			actions: enqueueActions(({ context, event, enqueue }) => {
-				const snapshot = find(context.pendingChanges, (c) => c.op === "save-view-snapshot");
-				if (snapshot) enqueue.sendTo(diagramActorRef, {
-					type: "update.view-bounds",
-					bounds: snapshot.layout.bounds
-				});
-				enqueue.assign({ pendingChanges: [] });
-			}),
-			...to.idle
-		},
-		onError: {
-			actions: assign(({ event }) => {
-				console.error("executeChanges onError", { error: event.error });
-				return { pendingChanges: [] };
-			}),
-			...to.idle
-		}
-	}
-});
-var editorActorLogic = machine.createMachine({
-	id: "editor",
-	context: ({ input }) => ({
-		viewId: input.viewId,
-		beforeEditing: null,
-		editing: null,
-		pendingChanges: [],
-		history: []
-	}),
-	initial: "idle",
-	states: {
-		idle,
-		editing,
-		pending,
-		afterEdit,
-		applyLatestToManual,
-		executeChanges
-	},
-	on: {
-		cancel: {
-			actions: [cancelSync(), assign({
-				editing: null,
-				beforeEditing: null,
-				pendingChanges: []
-			})],
-			...to.idle
-		},
-		synced: { actions: markHistoryAsSynched() },
-		undo: {
-			guard: "can undo",
-			actions: undo(),
-			...to.idle
-		},
-		change: { ...to.executeChanges },
-		"applyLatestToManual": { ...to.applyLatestToManual },
-		reset: {
-			actions: [
-				cancelSync(),
-				assign({
-					history: [],
-					editing: null,
-					beforeEditing: null,
-					pendingChanges: []
-				}),
-				stopHotkey()
-			],
-			...to.idle
-		}
-	}
-});
-//#endregion
-export { editorActorLogic };

package/dist/hooks/useOverlaysActor.js

@@ -1,11 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { selectDiagramActor, useDiagramSnapshot } from "./useDiagram.js";
-//#region src/hooks/useOverlaysActor.ts
-var select = selectDiagramActor((s) => {
-	return s.children.overlays;
-});
-function useOverlaysActorRef() {
-	return useDiagramSnapshot(select, Object.is);
-}
-//#endregion
-export { useOverlaysActorRef };

package/dist/hooks/useSearchActor.js

@@ -1,11 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { selectDiagramActor, useDiagramSnapshot } from "./useDiagram.js";
-//#region src/hooks/useSearchActor.ts
-var select = selectDiagramActor((s) => {
-	return s.children.search ?? null;
-});
-function useSearchActorRef() {
-	return useDiagramSnapshot(select, Object.is);
-}
-//#endregion
-export { useSearchActorRef };

package/dist/shadowroot/styles.css.d.ts

@@ -1,4 +0,0 @@
-export declare const cssInteractive: string;
-export declare function useBundledStyleSheet(injectFontCss: boolean, styleNonce?: string | (() => string) | undefined): CSSStyleSheet[];
-export type ColorScheme = 'light' | 'dark';
-export declare function useColorScheme(explicit?: ColorScheme): ColorScheme;

package/dist/shadowroot/styles.css.js

@@ -1,62 +0,0 @@
-import { __name } from "../_virtual/_rolldown/runtime.js";
-import { useCallbackRef as useCallbackRef$1 } from "../hooks/useCallbackRef.js";
-import styles_font_default from "../styles-font2.js";
-import styles_default from "../styles2.js";
-import { css } from "@likec4/styles/css";
-import { useState } from "react";
-import { useIsomorphicLayoutEffect } from "@react-hookz/web";
-import { first, isFunction, isString } from "remeda";
-import { useColorScheme, useMutationObserverTarget } from "@mantine/hooks";
-css({
-	cursor: "pointer",
-	["--mantine-cursor-pointer"]: "pointer",
-	"& :where(.likec4-diagram, .likec4-compound-node, .likec4-element-node)": { cursor: "pointer" }
-});
-function useBundledStyleSheet(injectFontCss, styleNonce) {
-	const [styleSheets] = useState(() => {
-		const css = new CSSStyleSheet();
-		css.replaceSync(
-			styles_default
-			/**
-			* replace only top-level body selectors, for example
-			* `body { }` should be replaced with `.likec4-shadow-root { }`
-			* but `.likec4-overlay-body { }` - not
-			*/
-		);
-		return [css];
-	});
-	useIsomorphicLayoutEffect(() => {
-		if (injectFontCss && !document.querySelector(`style[data-likec4-font]`)) {
-			const style = document.createElement("style");
-			style.setAttribute("type", "text/css");
-			style.setAttribute("data-likec4-font", "");
-			let nonce;
-			if (isString(styleNonce)) nonce = styleNonce;
-			if (isFunction(styleNonce)) nonce = styleNonce();
-			if (nonce) style.setAttribute("nonce", nonce);
-			style.appendChild(document.createTextNode(styles_font_default));
-			document.head.appendChild(style);
-		}
-	}, [injectFontCss]);
-	return styleSheets;
-}
-var getComputedColorScheme = () => {
-	try {
-		const colorScheme = first((window.getComputedStyle(document.documentElement).colorScheme ?? "").split(" "));
-		if (colorScheme === "light" || colorScheme === "dark") return colorScheme;
-	} catch {}
-	return null;
-};
-function useColorScheme$1(explicit) {
-	const preferred = useColorScheme();
-	const [computed, setComputed] = useState(getComputedColorScheme);
-	useMutationObserverTarget(useCallbackRef$1(() => setComputed(getComputedColorScheme)), {
-		attributes: true,
-		childList: false,
-		subtree: false
-	}, () => document.documentElement);
-	return explicit ?? computed ?? preferred;
-}
-__name(useColorScheme$1, "useColorScheme");
-//#endregion
-export { useBundledStyleSheet, useColorScheme$1 as useColorScheme };