Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

refactor(web): deblockify canvas documents (#6517)

dev-rbc73afd19732b
diff --git a/apps/web/src/features/block-canvas/component/Block.tsx b/apps/web/src/features/block-canvas/component/Block.tsx
index 643956167c..0d3812ccc6 100644
--- a/apps/web/src/features/block-canvas/component/Block.tsx
+++ b/apps/web/src/features/block-canvas/component/Block.tsx
@@ -1,5 +1,4 @@
import { useBlockEntityCommands } from '@app/features/next-soup/actions';
-import { createNumericParser } from '@block-canvas/util/parse';
import { FileSidePanelSections, SidePanel } from '@components/app/side-panel';
import {
useBlockId,
@@ -7,317 +6,73 @@ import {
useIsNestedBlock,
} from '@core/block';
import { DocumentBlockContainer } from '@core/component/DocumentBlockContainer';
-import { toast } from '@core/component/Toast/Toast';
import { createMethodRegistration } from '@core/orchestrator';
+import { blockHotkeyScopeSignal } from '@core/signal/blockElement';
import { blockFileSignal, blockHandleSignal } from '@core/signal/load';
-import type { IDocumentStorageServiceFile } from '@filesystem/file';
-import { storageServiceClient } from '@service-storage/client';
-import { createCallback } from '@solid-primitives/rootless';
-import { debounce } from '@solid-primitives/scheduled';
+import { useCanEdit } from '@core/signal/permissions';
import { useSearchParams } from '@solidjs/router';
-import {
- createEffect,
- createMemo,
- createRenderEffect,
- createResource,
- createSignal,
- on,
- onCleanup,
- Show,
-} from 'solid-js';
-import { blockDataSignal } from '../signal/canvasBlockData';
-import {
- pendingUpdates,
- useLoadCanvasData,
- useSaveCanvasDataImmediate,
-} from '../store/canvasData';
-import { isAnimating, renderStateStore } from '../store/RenderState';
-import { CanvasController } from './CanvasController';
-import { CanvasRenderer } from './CanvasRenderer';
-import { Loading } from './Loading';
+import { Show } from 'solid-js';
+import type { CanvasView } from '../context/canvas-document-context';
+import { CanvasDocument, type CanvasDocumentMethods } from './CanvasDocument';
import { ModalsProvider } from './ModalsProvider';
-import { ToolBar } from './ToolBar';
import { TopBar } from './TopBar';
-const LoadingView = () => (
- <div class="size-full flex items-center justify-center">
- <Loading />
- </div>
-);
-
-const parseParams = createNumericParser<{
- x?: number;
- y?: number;
- scale?: number;
-}>({
- x: ['x', 'canvas_x'],
- y: ['y', 'canvas_y'],
- scale: ['s', 'scale', 'canvas_scale'],
-});
-
-const numberOrUndefined = (
- n: string | undefined | null
-): number | undefined => {
- const num = Number(n);
- return n == null || Number.isNaN(num) ? undefined : num;
-};
-
-type BlockDataState = 'loading' | 'error' | 'blockdata' | 'initialized';
-
export type BlockCanvasProps = {
- view?: {
- x: number;
- y: number;
- scale: number;
- };
+ view?: CanvasView;
};
export default function BlockCanvas(props: BlockCanvasProps) {
useBlockEntityCommands();
const documentId = useBlockId();
- const isNestedBlock = useIsNestedBlock();
+ const isNested = useIsNestedBlock();
const nestedContext = useBlockNestedContext<'canvas'>();
- const loadCanvasData = useLoadCanvasData();
- const saveCanvasDataImmediate = useSaveCanvasDataImmediate();
- const [pending] = pendingUpdates;
- const [, setRenderState] = renderStateStore;
- const [dataState, setDataState] = createSignal<BlockDataState>('loading');
- const [visible, setVisible] = createSignal(false);
-
- // Flush pending saves on cleanup to prevent data loss when navigating away
- onCleanup(() => {
- if (pending()) {
- saveCanvasDataImmediate();
- }
- });
-
- // Also flush on page unload (refresh, close tab)
- createEffect(() => {
- const handleBeforeUnload = () => {
- if (pending()) {
- saveCanvasDataImmediate();
- }
- };
- window.addEventListener('beforeunload', handleBeforeUnload);
- onCleanup(() => {
- window.removeEventListener('beforeunload', handleBeforeUnload);
- });
- });
-
- createEffect(() => {
- const context = nestedContext?.parentContext;
- if (!context) return;
- const onLocationChange = context.canvas?.onLocationChange;
- if (!onLocationChange) return;
- const debouncedFn = debounce(onLocationChange, 100);
- if (!visible()) return;
-
- let initialized = false;
- createEffect(() => {
- const store = renderStateStore.get;
- let { x, y, scale } = store;
- const state = getCanvasState({ x, y, scale });
- // prevent the location from being set on the initial render if the view is the same as the initial view
- if (!initialized) {
- initialized = true;
- const initView = props.view;
- if (
- initView &&
- initView.x === state.x &&
- initView.y === state.y &&
- initView.scale === state.scale
- ) {
- return;
- }
- }
- debouncedFn(state);
- });
- });
-
- const blockDataLocationSource = createMemo(() => {
- if (props.view) return { sourceType: 'view' as const, data: props.view };
-
- if (isNestedBlock) return undefined;
- return { sourceType: 'blockData' as const, data: blockDataSignal() };
- });
- const [lastViewLocation, { refetch }] = createResource(
- blockDataLocationSource,
- async (source) => {
- if (source.sourceType === 'view') {
- return source.data;
- }
-
- const res = await storageServiceClient.getDocumentMetadata({
- documentId,
- init: {
- signal: AbortSignal.timeout(3000),
- },
- });
-
- if (res.isErr()) return null;
- const { viewLocation } = res.value;
-
- if (!viewLocation) return null;
- const initialParams = new URLSearchParams(viewLocation.replace('#', ''));
- const x = numberOrUndefined(initialParams.get('x'));
- const y = numberOrUndefined(initialParams.get('y'));
- const scale = numberOrUndefined(initialParams.get('s'));
- return { x, y, scale };
- }
- );
-
- createEffect(() => {
- const file = blockFileSignal();
- refetch();
- setDataState('blockdata');
- if (!file) {
- setDataState('error');
- return;
- }
- parseCanvasFile(file);
- });
-
- const [urlSearchParams] = useSearchParams();
- const [pendingLocationParams, setPendingLocationParams] =
- createSignal<Record<string, any>>();
+ const canEdit = useCanEdit();
+ const hotkeyScope = blockHotkeyScopeSignal.get;
+ const file = blockFileSignal.get;
const blockHandle = blockHandleSignal.get;
+ const [locationParams] = useSearchParams();
- createMethodRegistration(blockHandle, {
- goToLocationFromParams: (params: Record<string, any>) => {
- setPendingLocationParams(params);
- },
- });
-
- // null = no location, undefined = pending location, object = some location
- const computedLocation = createMemo(() => {
- if (props.view) return props.view;
- if (isNestedBlock) return null;
-
- const pendingLocation = parseParams(pendingLocationParams() || {});
- if (pendingLocation) return pendingLocation;
-
- const urlLocation = parseParams({ ...urlSearchParams });
- if (urlLocation) return urlLocation;
-
- const serverLocation = lastViewLocation();
- if (lastViewLocation.loading) {
- return undefined;
- }
- if (serverLocation) return serverLocation;
-
- return null;
- });
-
- const [centerContentsPending, setCenterContentsPending] = createSignal(false);
-
- createEffect(
- on([dataState, computedLocation], () => {
- if (dataState() === 'initialized') {
- const location = computedLocation();
- if (location) {
- setCanvasState(location);
- setTimeout(() => {
- setVisible(true);
- }, 10);
- } else if (location === null) {
- setCenterContentsPending(true);
- setVisible(true);
- } else {
- }
- }
- })
- );
-
- createRenderEffect((prev) => {
- if (visible() || !centerContentsPending()) return;
- const animating = isAnimating();
- if (prev && !animating) {
- setTimeout(() => {
- setVisible(true);
- }, 10);
- setCenterContentsPending(false);
- }
- return animating;
- });
-
- const getCanvasState = (state: {
- x?: number;
- y?: number;
- scale?: number;
- }) => {
- const x = state.x && !isNaN(state.x) ? Math.round(state.x) : 0;
- const y = state.y && !isNaN(state.y) ? Math.round(state.y) : 0;
- const scale =
- state.scale != null && !isNaN(state.scale)
- ? Math.round(state.scale * 100)
- : 100;
-
- return { x, y, scale };
+ const registerMethods = (methods: Partial<CanvasDocumentMethods>) => {
+ createMethodRegistration(blockHandle, methods);
};
- const setCanvasState = createCallback(
- (location: { x?: number; y?: number; scale?: number }) => {
- if (location.scale !== undefined && !isNaN(location.scale)) {
- setRenderState('scale', location.scale / 100);
- }
- if (location.x !== undefined && !isNaN(location.x)) {
- setRenderState('x', location.x);
- }
- if (location.y !== undefined && !isNaN(location.y)) {
- setRenderState('y', location.y);
- }
- }
- );
-
- async function parseCanvasFile(file: IDocumentStorageServiceFile) {
- try {
- const text = await file.text();
- const json = JSON.parse(text);
- await loadCanvasData(json);
- setDataState('initialized');
- } catch (e) {
- setDataState('error');
- toast.failure('Failed to parse canvas file');
- console.error(e);
- }
- return file;
- }
-
- const CanvasBody = () => (
- <Show when={dataState() === 'initialized'} fallback={<LoadingView />}>
- <CanvasController>
- <Show when={visible()}>
- <CanvasRenderer />
- <ToolBar />
- </Show>
- </CanvasController>
- </Show>
- );
-
return (
<DocumentBlockContainer>
- <div
- class="size-full select-none flex flex-col"
- // TODO: we need a more robust solution for preventing parent blocks from stealing clicks
- // This is a temporary fix for canvas in markdown but it doesn't necessarily generalize well
- on:click={(e) => {
- if (isNestedBlock) {
- e.stopPropagation();
- }
- }}
+ <CanvasDocument
+ documentId={documentId}
+ file={file()}
+ canEdit={canEdit()}
+ hotkeyScope={hotkeyScope()}
+ isNested={isNested}
+ portalScope="block"
+ view={props.view}
+ locationParams={locationParams}
+ onLocationChange={
+ nestedContext?.parentContext?.canvas?.onLocationChange
+ }
+ registerMethods={registerMethods}
>
- <ModalsProvider>
- <Show when={!isNestedBlock} fallback={<CanvasBody />}>
- <SidePanel.Layout defaultOpen={false}>
- <FileSidePanelSections />
- <div class="flex size-full min-w-0 flex-col overflow-hidden">
- <TopBar />
- <CanvasBody />
- </div>
- </SidePanel.Layout>
- </Show>
- </ModalsProvider>
- </div>
+ {(content) => (
+ <div
+ class="size-full select-none flex flex-col"
+ on:click={(event) => {
+ if (isNested) event.stopPropagation();
+ }}
+ >
+ <ModalsProvider>
+ <Show when={!isNested} fallback={content}>
+ <SidePanel.Layout defaultOpen={false}>
+ <FileSidePanelSections />
+ <div class="flex size-full min-w-0 flex-col overflow-hidden">
+ <TopBar />
+ {content}
+ </div>
+ </SidePanel.Layout>
+ </Show>
+ </ModalsProvider>
+ </div>
+ )}
+ </CanvasDocument>
</DocumentBlockContainer>
);
}
diff --git a/apps/web/src/features/block-canvas/component/CanvasController.tsx b/apps/web/src/features/block-canvas/component/CanvasController.tsx
index 9e490df7db..e715891727 100644
--- a/apps/web/src/features/block-canvas/component/CanvasController.tsx
+++ b/apps/web/src/features/block-canvas/component/CanvasController.tsx
@@ -1,5 +1,5 @@
import { useCanvasFileDrop } from '@block-canvas/signal/fileDrop';
-import { type BlockName, useBlockId, useIsNestedBlock } from '@core/block';
+import type { BlockName } from '@core/block';
import { FileDropOverlay } from '@core/component/FileDropOverlay';
import { OldMenu, OldMenuItem } from '@core/component/OldMenu';
import {
@@ -17,11 +17,7 @@ import { HEIC_EXTENSIONS, HEIC_MIME_TYPES } from '@core/heic/constants';
import { registerHotkey } from '@core/hotkey/hotkeys';
import { TOKENS } from '@core/hotkey/tokens';
import { HOTKEY_PRIORITY_HIGH } from '@core/hotkey/types';
-import { createMethodRegistration } from '@core/orchestrator';
-import { blockHotkeyScopeSignal } from '@core/signal/blockElement';
-import { blockHandleSignal } from '@core/signal/load';
import { trackMention } from '@core/signal/mention';
-import { useCanEdit } from '@core/signal/permissions';
import type { EntityDragEvent } from '@entity';
import TrashSimple from '@phosphor/trash-simple.svg';
import Clipboard from '@phosphor-icons/core/regular/clipboard.svg?component-solid';
@@ -56,6 +52,7 @@ import {
type Tool,
Tools,
} from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import { useConnect } from '../operation/connect';
import { fileHeight, fileWidth, useFile } from '../operation/file';
import { useImage } from '../operation/image';
@@ -71,24 +68,16 @@ import { useClipboard } from '../signal/clipboard';
import { useNudge } from '../signal/nudge';
import { useReorder } from '../signal/reorder';
import { useSelection } from '../signal/selection';
+import { useToolManager } from '../signal/toolManager';
import {
- handlersByToolSignal,
- middleMousePressedSignal,
- mouseDownPositionSignal,
- useToolManager,
-} from '../signal/toolManager';
-import {
- highestOrderSignal,
useCanvasEdges,
useCanvasNodes,
useCreateGroup,
useDeleteGroup,
- useExportCanvasData,
} from '../store/canvasData';
import { useRenderState } from '../store/RenderState';
import { type Vector2, vec2 } from '../util/vector2';
import { createContextMenu } from './ContextMenu';
-import { connectorTypeMenuTriggerSignal } from './TopBar';
false && observedSize;
false && fileDrop;
@@ -160,10 +149,10 @@ export function handleDelete() {
}
export function CanvasController(props: ParentProps) {
- const scopeId = blockHotkeyScopeSignal.get;
- const canEdit = useCanEdit();
- const isNestedBlock = useIsNestedBlock();
- const isDisabled = createMemo(() => isNestedBlock || !canEdit());
+ const canvas = useCanvasDocument();
+ const scopeId = canvas.hotkeyScope;
+ const canEdit = canvas.canEdit;
+ const isDisabled = createMemo(() => canvas.isNested() || !canEdit());
const renderState = useRenderState();
const toolManager = useToolManager();
const nodes = useCanvasNodes();
@@ -185,11 +174,10 @@ export function CanvasController(props: ParentProps) {
const createGroup = useCreateGroup();
const deleteGroup = useDeleteGroup();
const deleteSelection = handleDelete();
- const blockId = useBlockId();
- const [middleMousePressed] = middleMousePressedSignal;
- const [handlersByTool] = handlersByToolSignal;
- const [_, setConnectorTypeMenuTrigger] = connectorTypeMenuTriggerSignal;
- const exportCanvasData = useExportCanvasData();
+ const [middleMousePressed] = canvas.state.signals.middleMousePressed;
+ const [handlersByTool] = canvas.state.signals.handlersByTool;
+ const [, setConnectorTypeMenuTrigger] =
+ canvas.state.signals.connectorTypeMenuTrigger;
const imageExtensions = blockNameToFileExtensions.image;
const imageMimeTypes = blockNameToMimeTypes.image;
@@ -210,15 +198,6 @@ export function CanvasController(props: ParentProps) {
? [...canvasImageExtensions, ...videoExtensions]
: canvasImageExtensions;
- const blockHandle = blockHandleSignal.get;
-
- createMethodRegistration(blockHandle, {
- exportCanvas: async () => {
- const canvas = exportCanvasData();
- return canvas;
- },
- });
-
const [domRect, setDomRect] = createSignal<DOMRect | undefined>();
const [ref, setRef] = createSignal<HTMLDivElement>();
@@ -795,7 +774,7 @@ export function CanvasController(props: ParentProps) {
const centerVec = createMemo(() => {
return vec2(viewBox().x + viewBox().w / 2, viewBox().y + viewBox().h / 2);
});
- const highestOrder = highestOrderSignal.get;
+ const [highestOrder] = canvas.state.signals.highestOrder;
const droppable = createDroppable('canvas-input-' + _id);
const [dragDropState, { onDragEnd, onDragMove }] = useDragDropContext() ?? [
@@ -893,8 +872,8 @@ export function CanvasController(props: ParentProps) {
// Track document mention and get UUID
let mentionUuid: string | undefined;
- if (blockId && entityType === 'document') {
- mentionUuid = await trackMention(blockId, 'document', id);
+ if (entityType === 'document') {
+ mentionUuid = await trackMention(canvas.documentId(), 'document', id);
}
nodes.createNode(
@@ -961,7 +940,7 @@ export function CanvasController(props: ParentProps) {
dndDragMove(event as EntityDragEvent);
});
- const [_mouseDownPos, setMouseDownPos] = mouseDownPositionSignal;
+ const [, setMouseDownPos] = canvas.state.signals.mouseDownPosition;
// TODO (seamus) : Make a beter interface with the gesute library.
const pinch = usePinch(
diff --git a/apps/web/src/features/block-canvas/component/CanvasDocument.tsx b/apps/web/src/features/block-canvas/component/CanvasDocument.tsx
new file mode 100644
index 0000000000..679747a0f4
--- /dev/null
+++ b/apps/web/src/features/block-canvas/component/CanvasDocument.tsx
@@ -0,0 +1,281 @@
+import type { PortalScope } from '@core/component/ScopedPortal';
+import { toast } from '@core/component/Toast/Toast';
+import { debounce } from '@solid-primitives/scheduled';
+import {
+ createEffect,
+ createMemo,
+ createRenderEffect,
+ createResource,
+ createSignal,
+ type JSX,
+ on,
+ onCleanup,
+ Show,
+} from 'solid-js';
+import {
+ CanvasDocumentProvider,
+ type CanvasView,
+ useCanvasDocument,
+} from '../context/canvas-document-context';
+import type { Canvas } from '../model/CanvasModel';
+import { fetchCanvasViewLocation } from '../queries/canvas-document';
+import {
+ useExportCanvasData,
+ useLoadCanvasData,
+ useSaveCanvasDataImmediate,
+} from '../store/canvasData';
+import { createNumericParser } from '../util/parse';
+import { CanvasController } from './CanvasController';
+import { CanvasRenderer } from './CanvasRenderer';
+import { Loading } from './Loading';
+import { ToolBar } from './ToolBar';
+
+const parseParams = createNumericParser<{
+ x?: number;
+ y?: number;
+ scale?: number;
+}>({
+ x: ['x', 'canvas_x'],
+ y: ['y', 'canvas_y'],
+ scale: ['s', 'scale', 'canvas_scale'],
+});
+
+type CanvasDataState = 'loading' | 'error' | 'initialized';
+
+export type CanvasDocumentMethods = {
+ exportCanvas: () => Promise<Canvas>;
+ goToLocationFromParams: (params: Record<string, unknown>) => void;
+};
+
+export type CanvasDocumentProps = {
+ documentId: string;
+ file?: Blob;
+ canEdit: boolean;
+ hotkeyScope: string;
+ isNested?: boolean;
+ portalScope?: PortalScope;
+ view?: CanvasView;
+ locationParams?: Record<string, string | string[] | undefined>;
+ onLocationChange?: (location: CanvasView) => void;
+ registerMethods?: (methods: Partial<CanvasDocumentMethods>) => void;
+ children?: (content: JSX.Element) => JSX.Element;
+};
+
+export function CanvasDocument(props: CanvasDocumentProps) {
+ return (
+ <Show when={props.documentId} keyed>
+ {(documentId) => (
+ <CanvasDocumentProvider
+ documentId={documentId}
+ canEdit={props.canEdit}
+ isNested={props.isNested}
+ hotkeyScope={props.hotkeyScope}
+ portalScope={props.portalScope}
+ onLocationChange={props.onLocationChange}
+ >
+ <CanvasDocumentState {...props} />
+ </CanvasDocumentProvider>
+ )}
+ </Show>
+ );
+}
+
+function CanvasDocumentState(props: CanvasDocumentProps) {
+ const canvas = useCanvasDocument();
+ const { isNested, onLocationChange } = canvas;
+ const loadCanvasData = useLoadCanvasData();
+ const saveCanvasDataImmediate = useSaveCanvasDataImmediate();
+ const exportCanvasData = useExportCanvasData();
+ const [pending] = canvas.state.signals.pendingUpdates;
+ const [renderState, setRenderState] = canvas.state.stores.render;
+ const [animation] = canvas.state.stores.animation;
+ const [dataState, setDataState] = createSignal<CanvasDataState>('loading');
+ const [visible, setVisible] = createSignal(false);
+ const [pendingLocationParams, setPendingLocationParams] =
+ createSignal<Record<string, unknown>>();
+
+ props.registerMethods?.({
+ goToLocationFromParams: setPendingLocationParams,
+ });
+
+ createEffect(() => {
+ if (dataState() !== 'initialized') return;
+ props.registerMethods?.({
+ exportCanvas: async () => exportCanvasData(),
+ });
+ });
+
+ onCleanup(() => {
+ if (pending()) void saveCanvasDataImmediate();
+ });
+
+ createEffect(() => {
+ const handleBeforeUnload = () => {
+ if (pending()) void saveCanvasDataImmediate();
+ };
+ window.addEventListener('beforeunload', handleBeforeUnload);
+ onCleanup(() => {
+ window.removeEventListener('beforeunload', handleBeforeUnload);
+ });
+ });
+
+ createEffect(() => {
+ const notifyLocationChange = onLocationChange();
+ if (!notifyLocationChange || !visible()) return;
+
+ const notify = debounce(notifyLocationChange, 100);
+ let initialized = false;
+ createEffect(() => {
+ const { x, y, scale } = renderState;
+ const state = getCanvasState({ x, y, scale });
+ if (!initialized) {
+ initialized = true;
+ const initialView = props.view;
+ if (
+ initialView &&
+ initialView.x === state.x &&
+ initialView.y === state.y &&
+ initialView.scale === state.scale
+ ) {
+ return;
+ }
+ }
+ notify(state);
+ });
+ });
+
+ const locationSource = createMemo(() => {
+ if (props.view) return { type: 'view' as const, view: props.view };
+ if (isNested()) return;
+ return {
+ type: 'document' as const,
+ documentId: props.documentId,
+ file: props.file,
+ };
+ });
+ const [lastViewLocation] = createResource(locationSource, async (source) => {
+ if (source.type === 'view') return source.view;
+ return fetchCanvasViewLocation(source.documentId);
+ });
+
+ createEffect(() => {
+ const file = props.file;
+ setDataState('loading');
+ setVisible(false);
+ if (!file) {
+ setDataState('error');
+ return;
+ }
+
+ let cancelled = false;
+ const loadFile = async () => {
+ try {
+ const data: Canvas = JSON.parse(await file.text());
+ const loaded = await loadCanvasData(data, () => !cancelled);
+ if (loaded && !cancelled) setDataState('initialized');
+ } catch (error) {
+ if (cancelled) return;
+ setDataState('error');
+ toast.failure('Failed to parse canvas file');
+ console.error(error);
+ }
+ };
+ void loadFile();
+ onCleanup(() => {
+ cancelled = true;
+ });
+ });
+
+ const computedLocation = createMemo(() => {
+ if (props.view) return props.view;
+ if (isNested()) return null;
+
+ const pendingLocation = parseParams(pendingLocationParams() ?? {});
+ if (pendingLocation) return pendingLocation;
+
+ const urlLocation = parseParams(props.locationParams ?? {});
+ if (urlLocation) return urlLocation;
+
+ if (lastViewLocation.loading) return;
+ return lastViewLocation() ?? null;
+ });
+
+ const [centerContentsPending, setCenterContentsPending] = createSignal(false);
+
+ createEffect(
+ on([dataState, computedLocation], () => {
+ if (dataState() !== 'initialized') return;
+
+ const location = computedLocation();
+ if (location) {
+ setCanvasState(location);
+ setTimeout(() => setVisible(true), 10);
+ } else if (location === null) {
+ setCenterContentsPending(true);
+ setVisible(true);
+ }
+ })
+ );
+
+ createRenderEffect((wasAnimating) => {
+ if (visible() || !centerContentsPending()) return;
+
+ const animating = animation.isAnimating;
+ if (wasAnimating && !animating) {
+ setTimeout(() => setVisible(true), 10);
+ setCenterContentsPending(false);
+ }
+ return animating;
+ });
+
+ const setCanvasState = (location: {
+ x?: number;
+ y?: number;
+ scale?: number;
+ }) => {
+ if (location.scale !== undefined && !Number.isNaN(location.scale)) {
+ setRenderState('scale', location.scale / 100);
+ }
+ if (location.x !== undefined && !Number.isNaN(location.x)) {
+ setRenderState('x', location.x);
+ }
+ if (location.y !== undefined && !Number.isNaN(location.y)) {
+ setRenderState('y', location.y);
+ }
+ };
+
+ const content = (
+ <Show
+ when={dataState() === 'initialized'}
+ fallback={
+ <div class="flex size-full items-center justify-center">
+ <Loading />
+ </div>
+ }
+ >
+ <CanvasController>
+ <Show when={visible()}>
+ <CanvasRenderer />
+ <ToolBar />
+ </Show>
+ </CanvasController>
+ </Show>
+ );
+
+ return props.children ? props.children(content) : content;
+}
+
+function getCanvasState(state: {
+ x?: number;
+ y?: number;
+ scale?: number;
+}): CanvasView {
+ const x = state.x && !Number.isNaN(state.x) ? Math.round(state.x) : 0;
+ const y = state.y && !Number.isNaN(state.y) ? Math.round(state.y) : 0;
+ const scale =
+ state.scale != null && !Number.isNaN(state.scale)
+ ? Math.round(state.scale * 100)
+ : 100;
+
+ return { x, y, scale };
+}
diff --git a/apps/web/src/features/block-canvas/component/CanvasRenderer.tsx b/apps/web/src/features/block-canvas/component/CanvasRenderer.tsx
index b6cb98ffb5..5650ecb6f9 100644
--- a/apps/web/src/features/block-canvas/component/CanvasRenderer.tsx
+++ b/apps/web/src/features/block-canvas/component/CanvasRenderer.tsx
@@ -1,7 +1,5 @@
-import { useIsNestedBlock } from '@core/block';
import { LOCAL_ONLY } from '@core/constant/featureFlags';
import { isMobileWidth } from '@core/mobile/mobileWidth';
-import { useCanEdit } from '@core/signal/permissions';
import Circuitry from '@phosphor/circuitry.svg';
import { cn } from '@ui';
import { nanoid } from 'nanoid';
@@ -13,6 +11,7 @@ import {
Show,
} from 'solid-js';
import { type RenderMode, RenderModes } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import type { CanvasEdge, CanvasId, CanvasNode } from '../model/CanvasModel';
import { useSelection } from '../signal/selection';
import {
@@ -143,8 +142,7 @@ function CanvasLayer(
}
export function CanvasRenderer() {
- const canEdit = useCanEdit();
- const isNestedBlock = useIsNestedBlock();
+ const { canEdit, isNested } = useCanvasDocument();
const { currentSize, currentScale, currentPosition } = useRenderState();
const { selectionBox } = useSelection();
const nodes = useCanvasNodes();
@@ -192,7 +190,7 @@ export function CanvasRenderer() {
ref={(el) => {
baseLayerRef = el;
}}
- inert={isNestedBlock}
+ inert={isNested()}
>
<Show when={LOCAL_ONLY}>
<div class="pointer-events-none">
@@ -253,7 +251,7 @@ export function CanvasRenderer() {
ref={(el) => {
selectionLayerRef = el;
}}
- inert={isNestedBlock}
+ inert={isNested()}
/>
<CanvasLayer
@@ -261,7 +259,7 @@ export function CanvasRenderer() {
y={canvasY}
z={() => 2}
scale={scale}
- inert={isNestedBlock}
+ inert={isNested()}
>
<SelectionRenderer />
<SelectionBox rect={selectionBox()} />
@@ -275,7 +273,7 @@ export function CanvasRenderer() {
ref={(el) => {
lineSelectionLayerRef = el;
}}
- inert={isNestedBlock}
+ inert={isNested()}
/>
<Show when={!visibleObjects()}>
@@ -287,7 +285,7 @@ export function CanvasRenderer() {
</div>
</Show>
- <Show when={!isNestedBlock && canEdit()}>
+ <Show when={!isNested() && canEdit()}>
<div
class={cn(
'w-full absolute flex',
diff --git a/apps/web/src/features/block-canvas/component/ContextMenu.tsx b/apps/web/src/features/block-canvas/component/ContextMenu.tsx
index 8419ca59d3..8f4dd4dada 100644
--- a/apps/web/src/features/block-canvas/component/ContextMenu.tsx
+++ b/apps/web/src/features/block-canvas/component/ContextMenu.tsx
@@ -1,6 +1,6 @@
import { vec2 } from '@block-canvas/util/vector2';
-import { createBlockStore } from '@core/block';
import { OldMenu } from '@core/component/OldMenu';
+import { ScopedPortal } from '@core/component/ScopedPortal';
import clickOutside from '@core/directive/clickOutside';
import {
autoUpdate,
@@ -18,7 +18,7 @@ import {
type ParentProps,
Show,
} from 'solid-js';
-import { Portal } from 'solid-js/web';
+import { useCanvasDocument } from '../context/canvas-document-context';
interface BaseMenuProps {
open: boolean;
@@ -27,10 +27,11 @@ interface BaseMenuProps {
ref?: HTMLDivElement | ((ref: HTMLDivElement) => void);
}
export function BaseMenu(props: ParentProps<BaseMenuProps>) {
+ const { portalScope } = useCanvasDocument();
const safeChildren = children(() => props.open && props.children);
return (
<Show when={props.open}>
- <Portal>
+ <ScopedPortal scope={portalScope()}>
<div
style={{ left: `${props.x}px`, top: `${props.y}px` }}
class="absolute z-item-options-menu"
@@ -38,27 +39,16 @@ export function BaseMenu(props: ParentProps<BaseMenuProps>) {
>
<OldMenu width="md">{safeChildren()}</OldMenu>
</div>
- </Portal>
+ </ScopedPortal>
</Show>
);
}
-export const contextMenuStore = createBlockStore<{
- open: boolean;
- x: number;
- y: number;
- ref?: HTMLDivElement;
- mousePos?: { x: number; y: number };
-}>({
- open: false,
- x: 0,
- y: 0,
-});
-
export function createContextMenu(
anchorElement: Accessor<HTMLElement | undefined>
) {
- const [contextMenu, setContextMenu] = contextMenuStore;
+ const [contextMenu, setContextMenu] =
+ useCanvasDocument().state.stores.contextMenu;
const contextMenuPos = () => {
return vec2(contextMenu.x, contextMenu.y);
diff --git a/apps/web/src/features/block-canvas/component/FileSelector.tsx b/apps/web/src/features/block-canvas/component/FileSelector.tsx
index 3ffae9aeeb..24b81f064d 100644
--- a/apps/web/src/features/block-canvas/component/FileSelector.tsx
+++ b/apps/web/src/features/block-canvas/component/FileSelector.tsx
@@ -13,7 +13,7 @@ import { Dropdown } from '@ui';
import { createEffect, createSignal, Show } from 'solid-js';
import { VList } from 'virtua/solid';
import { Tools } from '../constants';
-import { selectedFileSignal } from '../operation/file';
+import { useCanvasDocument } from '../context/canvas-document-context';
import { useSelect } from '../operation/select';
import { useToolManager } from '../signal/toolManager';
@@ -24,7 +24,7 @@ type FileItem = {
};
function ItemOption(props: { file: FileItem; type: ItemType }) {
- const setSelectedFile = selectedFileSignal.set;
+ const [, setSelectedFile] = useCanvasDocument().state.signals.selectedFile;
const toolManager = useToolManager();
const select = useSelect();
diff --git a/apps/web/src/features/block-canvas/component/FloatingMenu.tsx b/apps/web/src/features/block-canvas/component/FloatingMenu.tsx
index 7d43ec989f..d50fc6e2d9 100644
--- a/apps/web/src/features/block-canvas/component/FloatingMenu.tsx
+++ b/apps/web/src/features/block-canvas/component/FloatingMenu.tsx
@@ -4,6 +4,7 @@ import { vec2 } from '@block-canvas/util/vector2';
import {
type DropdownPreset,
SlidableNumberInput,
+ type SlidableNumberInputProps,
} from '@core/component/SlidableNumberInput';
import { themeColors, themeStyles } from '@core/component/Themes';
import { isMobileWidth } from '@core/mobile/mobileWidth';
@@ -30,6 +31,7 @@ import {
} from 'solid-js';
import { unwrap } from 'solid-js/store';
import { Dynamic } from 'solid-js/web';
+import { useCanvasDocument } from '../context/canvas-document-context';
import type { CanvasEntityStyle, NodeType } from '../model/CanvasModel';
import { useCachedStyle } from '../signal/cachedStyle';
import { useCanvasHistory } from '../signal/canvasHistory';
@@ -52,6 +54,15 @@ import { LineWeight } from './icons-custom/LineWeight';
import { Swatch } from './Swatch';
type CanvasEntity = NodeType | 'edge';
+
+function CanvasSlidableNumberInput(props: SlidableNumberInputProps) {
+ const [, setActiveTextEditor] =
+ useCanvasDocument().state.signals.activeTextEditor;
+ return (
+ <SlidableNumberInput {...props} onEditingChange={setActiveTextEditor} />
+ );
+}
+
type ColorOption = {
base: string;
fill: string;
@@ -533,7 +544,7 @@ export function FloatingMenu() {
<ReverseEdgeButton />
</div>
<div class="flex flex-row justify-between">
- <SlidableNumberInput
+ <CanvasSlidableNumberInput
icon={
sharedStyles().get('fromEndStyle')
? arrowStylePresets[sharedStyles().get('fromEndStyle')]
@@ -556,7 +567,7 @@ export function FloatingMenu() {
fullIcon={true}
tooltip="Line start"
/>
- <SlidableNumberInput
+ <CanvasSlidableNumberInput
icon={
sharedStyles().get('connectionStyle')
? connectionStylePresets[
@@ -582,7 +593,7 @@ export function FloatingMenu() {
fullIcon={true}
tooltip="Connection type"
/>
- <SlidableNumberInput
+ <CanvasSlidableNumberInput
icon={
sharedStyles().get('toEndStyle')
? arrowStylePresets[sharedStyles().get('toEndStyle')].icon!
@@ -677,7 +688,7 @@ export function FloatingMenu() {
<div class="flex flex-row">
<Show when={validMenus().has('strokeWidth')}>
<div class={cn(!isMobileWidth() && 'mr-3.5')}>
- <SlidableNumberInput
+ <CanvasSlidableNumberInput
label={'Line weight'}
labelPosition="top"
icon={LineWeight}
@@ -724,7 +735,7 @@ export function FloatingMenu() {
</div>
</Show>
<Show when={!isMobileWidth() && validMenus().has('cornerRadius')}>
- <SlidableNumberInput
+ <CanvasSlidableNumberInput
label={'Corner rounding'}
labelPosition="top"
icon={CornersOut}
@@ -776,7 +787,7 @@ export function FloatingMenu() {
'ml-2'
)}
>
- <SlidableNumberInput
+ <CanvasSlidableNumberInput
label={'Font size'}
labelPosition="top"
icon={TextAa}
diff --git a/apps/web/src/features/block-canvas/component/MediaSelector.tsx b/apps/web/src/features/block-canvas/component/MediaSelector.tsx
index 584b4d1f1d..2d17202572 100644
--- a/apps/web/src/features/block-canvas/component/MediaSelector.tsx
+++ b/apps/web/src/features/block-canvas/component/MediaSelector.tsx
@@ -1,7 +1,4 @@
-import {
- canvasDraggingSignal,
- useCanvasFileDrop,
-} from '@block-canvas/signal/fileDrop';
+import { useCanvasFileDrop } from '@block-canvas/signal/fileDrop';
import { useRenderState } from '@block-canvas/store/RenderState';
import { vec2 } from '@block-canvas/util/vector2';
import { EntityIcon } from '@core/component/EntityIcon';
@@ -26,7 +23,7 @@ import { Dropdown } from '@ui';
import { createMemo, createSignal, Show } from 'solid-js';
import { VList } from 'virtua/solid';
import { Tools } from '../constants';
-import { selectedImageSignal } from '../operation/image';
+import { useCanvasDocument } from '../context/canvas-document-context';
import { useSelect } from '../operation/select';
import { useToolManager } from '../signal/toolManager';
@@ -42,7 +39,7 @@ type MediaItem = {
};
function ItemOption(props: { media: MediaItem }) {
- const setSelectedImage = selectedImageSignal.set;
+ const [, setSelectedImage] = useCanvasDocument().state.signals.selectedImage;
const toolManager = useToolManager();
const select = useSelect();
@@ -79,7 +76,8 @@ export function MediaSelector() {
//const copiedFileID = copiedFile();
const select = useSelect();
const { handleFileDrop } = useCanvasFileDrop();
- const [isDragging, setIsDragging] = canvasDraggingSignal;
+ const [isDragging, setIsDragging] =
+ useCanvasDocument().state.signals.canvasDragging;
const { viewBox } = useRenderState();
const centerVec = createMemo(() => {
return vec2(viewBox().x + viewBox().w / 2, viewBox().y + viewBox().h / 2);
diff --git a/apps/web/src/features/block-canvas/component/ToolBar.tsx b/apps/web/src/features/block-canvas/component/ToolBar.tsx
index ff095a3a06..1b66138a4c 100644
--- a/apps/web/src/features/block-canvas/component/ToolBar.tsx
+++ b/apps/web/src/features/block-canvas/component/ToolBar.tsx
@@ -4,7 +4,6 @@ import {
} from '@block-canvas/model/CanvasModel';
import { useCachedStyle } from '@block-canvas/signal/cachedStyle';
import { useToolManager } from '@block-canvas/signal/toolManager';
-import { useIsNestedBlock } from '@core/block';
import { ScopedPortal } from '@core/component/ScopedPortal';
import {
ENABLE_CANVAS_FILES,
@@ -14,8 +13,6 @@ import {
import { registerHotkey } from '@core/hotkey/hotkeys';
import { TOKENS } from '@core/hotkey/tokens';
import { isTouchDevice } from '@core/mobile/isTouchDevice';
-import { blockHotkeyScopeSignal } from '@core/signal/blockElement';
-import { useCanEdit } from '@core/signal/permissions';
import CaretDown from '@phosphor/caret-down.svg';
import Cursor from '@phosphor/cursor.svg';
import Hand from '@phosphor/hand.svg';
@@ -28,6 +25,7 @@ import { Button, ButtonGroup, Dropdown, Hotkey, Toolbar } from '@ui';
import { createSignal, Show } from 'solid-js';
import { Dynamic } from 'solid-js/web';
import { Tools } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import { FileSelector } from './FileSelector';
import {
ConnectorBezierArrows,
@@ -35,13 +33,13 @@ import {
ConnectorStraightArrows,
} from './icons-custom/ArrowIcons';
import { MediaSelector } from './MediaSelector';
-import { connectorTypeMenuTriggerSignal } from './TopBar';
const ConnectorTypeSubMenu = (props: {
onSelect: (connectionStye: EdgeConnectionStyle) => void;
}) => {
+ const state = useCanvasDocument().state.signals;
const [connectorTypeMenuTrigger, setConnectorTypeMenuTrigger] =
- connectorTypeMenuTriggerSignal;
+ state.connectorTypeMenuTrigger;
return (
<Dropdown
@@ -100,15 +98,14 @@ const ConnectorTypeSubMenu = (props: {
};
export function ToolBar() {
- const baseCanEdit = useCanEdit();
- const isNested = useIsNestedBlock();
- const canEdit = () => baseCanEdit() && !isNested;
+ const canvas = useCanvasDocument();
+ const canEdit = () => canvas.canEdit() && !canvas.isNested();
const toolManager = useToolManager();
const cachedStyle = useCachedStyle();
const { activeTool } = toolManager;
const [connectorTypeMenuTrigger, setConnectorTypeMenuTrigger] =
- connectorTypeMenuTriggerSignal;
- const scopeId = blockHotkeyScopeSignal.get;
+ canvas.state.signals.connectorTypeMenuTrigger;
+ const scopeId = canvas.hotkeyScope;
const [connectionStyle, setConnectionStyle] =
createSignal<EdgeConnectionStyle>('straight');
@@ -171,7 +168,7 @@ export function ToolBar() {
});
return (
- <ScopedPortal scope="block">
+ <ScopedPortal scope={canvas.portalScope()}>
{/* Full-frame mobile/tablet: rest above the floating bottom chrome. */}
<Toolbar
size="icon-sm"
diff --git a/apps/web/src/features/block-canvas/component/TopBar.tsx b/apps/web/src/features/block-canvas/component/TopBar.tsx
index 564ed5bce9..6cd2691379 100644
--- a/apps/web/src/features/block-canvas/component/TopBar.tsx
+++ b/apps/web/src/features/block-canvas/component/TopBar.tsx
@@ -16,7 +16,7 @@ import {
} from '@components/app/split-layout/components/SplitHeader';
import { BlockItemSplitLabel } from '@components/app/split-layout/components/SplitLabel';
import { useIsAuthenticated } from '@core/auth';
-import { createBlockSignal, useBlockId } from '@core/block';
+import { useBlockId } from '@core/block';
import { DETAILS_DRAWER_ID } from '@core/component/DetailsDrawer';
import { BlockLiveIndicators } from '@core/component/LiveIndicators';
import {
@@ -44,12 +44,10 @@ import IconShared from '@phosphor/share.svg';
import { createCallback } from '@solid-primitives/rootless';
import { onMount } from 'solid-js';
import { URL_PARAMS } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import { useToolManager } from '../signal/toolManager';
-import { currentSavedFile } from '../store/canvasData';
import { useRenderState } from '../store/RenderState';
-export const connectorTypeMenuTriggerSignal = createBlockSignal(false);
-
export function TopBar() {
const analytics = useAnalytics();
@@ -57,7 +55,8 @@ export function TopBar() {
const toolManager = useToolManager();
const { getLocation } = useRenderState();
- const getCurrentSavedFile = currentSavedFile.get;
+ const [getCurrentSavedFile] =
+ useCanvasDocument().state.signals.currentSavedFile;
const documentId = useBlockId();
const fileName = useBlockDocumentName('Unknown Filename');
const downloadName = useBlockDocumentDownloadName('Unknown Filename');
diff --git a/apps/web/src/features/block-canvas/component/nodes/EntityMention.tsx b/apps/web/src/features/block-canvas/component/nodes/EntityMention.tsx
index 047848489a..c5d9147b3b 100644
--- a/apps/web/src/features/block-canvas/component/nodes/EntityMention.tsx
+++ b/apps/web/src/features/block-canvas/component/nodes/EntityMention.tsx
@@ -1,7 +1,7 @@
import { useToolManager } from '@block-canvas/signal/toolManager';
import { useRenderState } from '@block-canvas/store/RenderState';
import { useSplitLayout } from '@components/app/split-layout/layout';
-import { type BlockName, useBlockId } from '@core/block';
+import type { BlockName } from '@core/block';
import { CircleSpinner } from '@core/component/CircleSpinner';
import { PopupPreview } from '@core/component/DocumentPreview';
import { EntityIcon, getPreviewItemIconType } from '@core/component/EntityIcon';
@@ -21,6 +21,7 @@ import {
Switch,
} from 'solid-js';
import { DRAG_THRESHOLD, type RenderMode, Tools } from '../../constants';
+import { useCanvasDocument } from '../../context/canvas-document-context';
import type { EntityMentionNode } from '../../model/CanvasModel';
import { fileWidth } from '../../operation/file';
import { type Vector2, vec2 } from '../../util/vector2';
@@ -90,7 +91,7 @@ export function File(props: { node: EntityMentionNode; mode: RenderMode }) {
'UNAUTHORIZED' | 'MISSING' | 'INVALID' | 'LOADING' | undefined
>('LOADING');
- const blockId = useBlockId();
+ const blockId = useCanvasDocument().documentId();
const { openWithSplit } = useSplitLayout();
diff --git a/apps/web/src/features/block-canvas/component/nodes/Shape.tsx b/apps/web/src/features/block-canvas/component/nodes/Shape.tsx
index e4b10b953e..a0e8d84b39 100644
--- a/apps/web/src/features/block-canvas/component/nodes/Shape.tsx
+++ b/apps/web/src/features/block-canvas/component/nodes/Shape.tsx
@@ -1,6 +1,5 @@
import { useToolManager } from '@block-canvas/signal/toolManager';
import { useUpdateNode } from '@block-canvas/store/canvasData';
-import { useCanEdit } from '@core/signal/permissions';
import {
createEffect,
createMemo,
@@ -14,6 +13,7 @@ import {
Switch,
} from 'solid-js';
import { type RenderMode, RenderModes } from '../../constants';
+import { useCanvasDocument } from '../../context/canvas-document-context';
import type { ShapeNode, ShapeType } from '../../model/CanvasModel';
import type { Color } from '../../util/color';
import { getBorderRadius, getTailwindColor, opacity } from '../../util/style';
@@ -34,7 +34,7 @@ function Label(props: {
onFocus?: (value: string) => void;
onBlur?: (value: string) => void;
}) {
- const canEdit = useCanEdit();
+ const canEdit = useCanvasDocument().canEdit;
const toolManager = useToolManager();
let labelRef!: HTMLSpanElement;
const [hasFocus, setHasFocus] = createSignal(false);
diff --git a/apps/web/src/features/block-canvas/component/nodes/TextBox.tsx b/apps/web/src/features/block-canvas/component/nodes/TextBox.tsx
index c160345163..6c796cd410 100644
--- a/apps/web/src/features/block-canvas/component/nodes/TextBox.tsx
+++ b/apps/web/src/features/block-canvas/component/nodes/TextBox.tsx
@@ -1,5 +1,4 @@
import { type Vector2, vec2 } from '@block-canvas/util/vector2';
-import { useBlockId } from '@core/block';
import { buildConfig } from '@core/component/LexicalMarkdown/builder/MarkdownConfigBuilder';
import { DecoratorRenderer } from '@core/component/LexicalMarkdown/component/core/DecoratorRenderer';
import { NodeAccessoryRenderer } from '@core/component/LexicalMarkdown/component/core/NodeAccessoryRenderer';
@@ -11,9 +10,7 @@ import {
DefaultShortcuts,
keyboardShortcutsPlugin,
} from '@core/component/LexicalMarkdown/plugins';
-import { ScopedPortal } from '@core/component/ScopedPortal';
import clickOutside from '@core/directive/clickOutside';
-import { useCanEdit } from '@core/signal/permissions';
import {
$getRoot,
$setSelection,
@@ -41,6 +38,7 @@ import {
type Tool,
Tools,
} from '../../constants';
+import { useCanvasDocument } from '../../context/canvas-document-context';
import type { TextNode } from '../../model/CanvasModel';
import { useCanvasHistory } from '../../signal/canvasHistory';
import { useSelection } from '../../signal/selection';
@@ -65,7 +63,9 @@ function TextBoxEditor(props: {
blockId?: string;
}) {
const { registerEditor, unregisterEditor } = useTextNodeEditors();
- const canEdit = useCanEdit();
+ const canvas = useCanvasDocument();
+ const canEdit = canvas.canEdit;
+ const useBlockBoundary = () => canvas.portalScope() === 'block';
let mountRef!: HTMLDivElement;
const toolManager = useToolManager();
@@ -206,28 +206,29 @@ function TextBoxEditor(props: {
}}
contentEditable={props.editable()}
/>
- <ScopedPortal>
- <MentionsMenu
- editor={editor}
- menu={state.mentionsMenuOps!}
- useBlockBoundary={true}
- />
- <EmojiMenu
- editor={editor}
- menu={state.emojisMenuOps!}
- useBlockBoundary={true}
- />
- <Show when={state.snippetsMenuOps}>
- {(menu) => (
- <SnippetsMenu
- editor={editor}
- menu={menu()}
- useBlockBoundary={true}
- sourceDocumentId={props.blockId}
- />
- )}
- </Show>
- </ScopedPortal>
+ <MentionsMenu
+ editor={editor}
+ menu={state.mentionsMenuOps!}
+ useBlockBoundary={useBlockBoundary()}
+ portalScope={canvas.portalScope()}
+ />
+ <EmojiMenu
+ editor={editor}
+ menu={state.emojisMenuOps!}
+ useBlockBoundary={useBlockBoundary()}
+ portalScope={canvas.portalScope()}
+ />
+ <Show when={state.snippetsMenuOps}>
+ {(menu) => (
+ <SnippetsMenu
+ editor={editor}
+ menu={menu()}
+ useBlockBoundary={useBlockBoundary()}
+ portalScope={canvas.portalScope()}
+ sourceDocumentId={props.blockId}
+ />
+ )}
+ </Show>
<DecoratorRenderer editor={editor} />
<NodeAccessoryRenderer editor={editor} store={state.accessoryStore!} />
</LexicalWrapperContext.Provider>
@@ -235,13 +236,14 @@ function TextBoxEditor(props: {
}
export function TextBox(props: { node: TextNode; mode: RenderMode }) {
- const canEdit = useCanEdit();
+ const canvas = useCanvasDocument();
+ const canEdit = canvas.canEdit;
const activeTool = useToolManager().activeTool;
const history = useCanvasHistory();
const selection = useSelection();
const nodes = useCanvasNodes();
const toolManager = useToolManager();
- const blockId = useBlockId();
+ const blockId = canvas.documentId();
const style = createMemo((): Partial<JSX.CSSProperties> => {
return {
diff --git a/apps/web/src/features/block-canvas/context/canvas-document-context.tsx b/apps/web/src/features/block-canvas/context/canvas-document-context.tsx
new file mode 100644
index 0000000000..bd9d7d295f
--- /dev/null
+++ b/apps/web/src/features/block-canvas/context/canvas-document-context.tsx
@@ -0,0 +1,72 @@
+import type { PortalScope } from '@core/component/ScopedPortal';
+import type { Accessor, FlowComponent, Owner } from 'solid-js';
+import { createContext, getOwner, useContext } from 'solid-js';
+import {
+ type CanvasDocumentState,
+ createCanvasDocumentState,
+} from './canvas-document-state';
+
+export type CanvasView = {
+ x: number;
+ y: number;
+ scale: number;
+};
+
+export type CanvasDocumentContextValue = {
+ documentId: Accessor<string>;
+ canEdit: Accessor<boolean>;
+ isNested: Accessor<boolean>;
+ hotkeyScope: Accessor<string>;
+ portalScope: Accessor<PortalScope>;
+ onLocationChange: Accessor<((location: CanvasView) => void) | undefined>;
+ state: CanvasDocumentState;
+ instanceOwner?: Owner;
+};
+
+export type CanvasDocumentProviderProps = {
+ documentId: string;
+ canEdit: boolean;
+ isNested?: boolean;
+ hotkeyScope: string;
+ portalScope?: PortalScope;
+ onLocationChange?: (location: CanvasView) => void;
+};
+
+const CanvasDocumentContext = createContext<CanvasDocumentContextValue>();
+
+const CanvasDocumentOwner: FlowComponent = (props) => {
+ const context = useContext(CanvasDocumentContext);
+ if (!context) throw new Error('CanvasDocumentOwner requires its provider');
+ context.instanceOwner = getOwner() ?? undefined;
+ return props.children;
+};
+
+export const CanvasDocumentProvider: FlowComponent<
+ CanvasDocumentProviderProps
+> = (props) => {
+ const context: CanvasDocumentContextValue = {
+ documentId: () => props.documentId,
+ canEdit: () => props.canEdit,
+ isNested: () => props.isNested ?? false,
+ hotkeyScope: () => props.hotkeyScope,
+ portalScope: () => props.portalScope ?? 'split',
+ onLocationChange: () => props.onLocationChange,
+ state: createCanvasDocumentState(),
+ };
+
+ return (
+ <CanvasDocumentContext.Provider value={context}>
+ <CanvasDocumentOwner>{props.children}</CanvasDocumentOwner>
+ </CanvasDocumentContext.Provider>
+ );
+};
+
+export function useCanvasDocument(): CanvasDocumentContextValue {
+ const context = useContext(CanvasDocumentContext);
+ if (!context) {
+ throw new Error(
+ 'useCanvasDocument must be used within a CanvasDocumentProvider'
+ );
+ }
+ return context;
+}
diff --git a/apps/web/src/features/block-canvas/context/canvas-document-state.ts b/apps/web/src/features/block-canvas/context/canvas-document-state.ts
new file mode 100644
index 0000000000..8d35349a83
--- /dev/null
+++ b/apps/web/src/features/block-canvas/context/canvas-document-state.ts
@@ -0,0 +1,137 @@
+import { type Tool, Tools } from '@block-canvas/constants';
+import {
+ type CanvasEdge,
+ type CanvasEntityStyle,
+ type CanvasGroup,
+ type CanvasId,
+ type CanvasNode,
+ EdgeConnectionStyles,
+} from '@block-canvas/model/CanvasModel';
+import type { ItemType } from '@service-storage/client';
+import type { LexicalEditor } from 'lexical';
+import { createSignal } from 'solid-js';
+import { createStore } from 'solid-js/store';
+import type { ConnectOperation } from '../operation/connect';
+import type { FileOperation } from '../operation/file';
+import type { ImageOperation } from '../operation/image';
+import type { MoveOperation } from '../operation/move';
+import type { Operator } from '../operation/operation';
+import type { PencilOperation } from '../operation/pencil';
+import type { RescaleOperation } from '../operation/rescale';
+import type { SelectOperation } from '../operation/select';
+import type { ShapeOperation } from '../operation/shape';
+import type { TextOperation } from '../operation/text';
+import type { Snapshot } from '../signal/canvasHistory';
+import type { RenderState } from '../store/RenderState';
+import type { Rectangle } from '../util/rectangle';
+import { getTailwindColor } from '../util/style';
+import type { Vector2 } from '../util/vector2';
+
+export type CanvasAnimationState = {
+ startX: number;
+ startY: number;
+ startScale: number;
+ targetX: number;
+ targetY: number;
+ targetScale: number;
+ startTime: number;
+ duration: number;
+ isAnimating: boolean;
+};
+
+export type CanvasContextMenuState = {
+ open: boolean;
+ x: number;
+ y: number;
+ ref?: HTMLDivElement;
+ mousePos?: { x: number; y: number };
+};
+
+const defaultStyle = (): CanvasEntityStyle => ({
+ fillColor: getTailwindColor('neutral-100'),
+ strokeColor: getTailwindColor('neutral-700'),
+ strokeWidth: 2,
+ cornerRadius: 0,
+ opacity: 1,
+ textSize: 16,
+ connectionStyle: EdgeConnectionStyles.straight,
+});
+
+export function createCanvasDocumentState() {
+ return {
+ stores: {
+ nodes: createStore<Record<CanvasId, CanvasNode>>({}),
+ edges: createStore<Record<CanvasId, CanvasEdge>>({}),
+ groups: createStore<Record<CanvasId, CanvasGroup>>({}),
+ render: createStore<RenderState>({
+ x: 0,
+ y: 0,
+ scale: 1,
+ containerRect: undefined,
+ }),
+ animation: createStore<CanvasAnimationState>({
+ startX: 0,
+ startY: 0,
+ startScale: 1,
+ targetX: 0,
+ targetY: 0,
+ targetScale: 1,
+ startTime: 0,
+ duration: 0,
+ isAnimating: false,
+ }),
+ cachedStyle: createStore<CanvasEntityStyle>(defaultStyle()),
+ contextMenu: createStore<CanvasContextMenuState>({
+ open: false,
+ x: 0,
+ y: 0,
+ }),
+ textNodeEditors: createStore<Record<string, LexicalEditor>>({}),
+ },
+ signals: {
+ selectedNodeIds: createSignal<Set<string>>(new Set()),
+ selectedEdgeIds: createSignal<Set<string>>(new Set()),
+ selectedGroupIds: createSignal<Set<string>>(new Set()),
+ selectionBox: createSignal<Rectangle>(),
+ lastSelectedNodeIds: createSignal<Set<string>>(new Set()),
+ lastSelectedEdgeIds: createSignal<Set<string>>(new Set()),
+ history: createSignal<Snapshot[]>([]),
+ currentHistory: createSignal<Snapshot>(),
+ currentHistoryIndex: createSignal(-1),
+ highestOrder: createSignal(0),
+ lastCreatedNodeId: createSignal<CanvasId>(),
+ pendingUpdates: createSignal(false),
+ currentSavedFile: createSignal<Blob | null>(null),
+ selectedTool: createSignal<Tool>(Tools.Grab),
+ handlersByTool: createSignal<Map<Tool, Operator[]>>(new Map()),
+ mouseDownPosition: createSignal<Vector2>(),
+ mousePosition: createSignal<Vector2>(),
+ lastMousePosition: createSignal<Vector2>(),
+ rawMouseDownPosition: createSignal<Vector2>(),
+ activeTextEditor: createSignal(false),
+ middleMousePressed: createSignal<boolean>(),
+ canvasDragging: createSignal(false),
+ connectorTypeMenuTrigger: createSignal(false),
+ currentConnectOperation: createSignal<ConnectOperation>(),
+ currentShapeOperation: createSignal<ShapeOperation>(),
+ currentRescaleOperation: createSignal<RescaleOperation>(),
+ currentPencilOperation: createSignal<PencilOperation>(),
+ currentTextOperation: createSignal<TextOperation>(),
+ currentMoveOperation: createSignal<MoveOperation>(),
+ selectedImage: createSignal<{
+ type: 'image' | 'video';
+ id: string;
+ }>(),
+ currentImageOperation: createSignal<ImageOperation>(),
+ currentSelectOperation: createSignal<SelectOperation>(),
+ selectedFile: createSignal<{
+ type?: ItemType;
+ id?: string;
+ }>({}),
+ currentFileOperation: createSignal<FileOperation>(),
+ },
+ instances: new Map<symbol, unknown>(),
+ };
+}
+
+export type CanvasDocumentState = ReturnType<typeof createCanvasDocumentState>;
diff --git a/apps/web/src/features/block-canvas/operation/connect.ts b/apps/web/src/features/block-canvas/operation/connect.ts
index c883df7b66..536003664f 100644
--- a/apps/web/src/features/block-canvas/operation/connect.ts
+++ b/apps/web/src/features/block-canvas/operation/connect.ts
@@ -4,11 +4,11 @@ import {
radiansToDegrees,
snapTo,
} from '@block-canvas/util/math';
-import { createBlockSignal } from '@core/block';
import { DEV_MODE_ENV } from '@core/constant/featureFlags';
import { unwrap } from 'solid-js/store';
import type { Edge } from '../constants';
import { OPERATION_LOGGING, Tools } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import type {
CanvasEdge,
CanvasId,
@@ -18,11 +18,7 @@ import type {
import { useCachedStyle } from '../signal/cachedStyle';
import { useCanvasHistory } from '../signal/canvasHistory';
import { useSelection } from '../signal/selection';
-import {
- highestOrderSignal,
- useCanvasEdges,
- useEdgeUtils,
-} from '../store/canvasData';
+import { useCanvasEdges, useEdgeUtils } from '../store/canvasData';
import { useRenderState } from '../store/RenderState';
import { sharedInstance } from '../util/sharedInstance';
import { type Vector2, vec2 } from '../util/vector2';
@@ -70,9 +66,6 @@ export type ConnectOperation = Operation & {
editExisting?: true;
};
-export const currentConnectOperationSignal =
- createBlockSignal<ConnectOperation>();
-
function freeEnd(x: number, y: number): FreeEnd {
return {
type: 'free',
@@ -93,13 +86,13 @@ export type ConnectOperator = ReturnType<typeof useConnect>;
export const useConnect = sharedInstance(() => {
const [currentConnectOperation, setCurrentConnectOperation] =
- currentConnectOperationSignal;
+ useCanvasDocument().state.signals.currentConnectOperation;
const edges = useCanvasEdges();
const { selectEdge, deselectAll } = useSelection();
const { clientToCanvas } = useRenderState();
const history = useCanvasHistory();
const cachedStyle = useCachedStyle();
- const highestOrder = highestOrderSignal.get;
+ const highestOrder = useCanvasDocument().state.signals.highestOrder[0];
const { setSelectedTool } = useToolManager();
const edgeUtils = useEdgeUtils();
diff --git a/apps/web/src/features/block-canvas/operation/file.ts b/apps/web/src/features/block-canvas/operation/file.ts
index fec119b49f..3c60471403 100644
--- a/apps/web/src/features/block-canvas/operation/file.ts
+++ b/apps/web/src/features/block-canvas/operation/file.ts
@@ -1,27 +1,18 @@
-import { createBlockSignal, useBlockId } from '@core/block';
import { DEV_MODE_ENV } from '@core/constant/featureFlags';
import { trackMention } from '@core/signal/mention';
import { copiedItem } from '@core/state/clipboard';
-import type { ItemType } from '@service-storage/client';
import { unwrap } from 'solid-js/store';
import { OPERATION_LOGGING, Tools } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import type { EntityMentionNode } from '../model/CanvasModel';
import { useCanvasHistory } from '../signal/canvasHistory';
import { useToolManager } from '../signal/toolManager';
-import { highestOrderSignal, useCanvasNodes } from '../store/canvasData';
+import { useCanvasNodes } from '../store/canvasData';
import { useRenderState } from '../store/RenderState';
import { sharedInstance } from '../util/sharedInstance';
import type { Vector2 } from '../util/vector2';
import type { Operation, Operator } from './operation';
-export const selectedFileSignal = createBlockSignal<{
- type?: ItemType;
- id?: string;
-}>({
- type: undefined,
- id: undefined,
-});
-
export const fileWidth = 250;
export const fileHeight = 50;
@@ -36,20 +27,19 @@ export type FileOperation = Operation & {
node: EntityMentionNode;
};
-export const currentFileOperationSignal = createBlockSignal<FileOperation>();
-
export const useFile = sharedInstance((): Operator => {
+ const canvas = useCanvasDocument();
+ const state = canvas.state.signals;
const { pageToCanvas } = useRenderState();
const { createNode, updateNode, ...nodes } = useCanvasNodes();
const [currentFileOperation, setCurrentFileOperation] =
- currentFileOperationSignal;
+ state.currentFileOperation;
const { setSelectedTool } = useToolManager();
const history = useCanvasHistory();
- const highestOrder = highestOrderSignal.get;
- const blockId = useBlockId();
+ const [highestOrder] = state.highestOrder;
+ const blockId = canvas.documentId();
- const selectedFile = selectedFileSignal.get;
- const setSelectedFile = selectedFileSignal.set;
+ const [selectedFile, setSelectedFile] = state.selectedFile;
function _applyMousePos(mousePos: Vector2) {
const op = currentFileOperation();
diff --git a/apps/web/src/features/block-canvas/operation/image.ts b/apps/web/src/features/block-canvas/operation/image.ts
index 98d7fc9d8b..fef83254d3 100644
--- a/apps/web/src/features/block-canvas/operation/image.ts
+++ b/apps/web/src/features/block-canvas/operation/image.ts
@@ -1,21 +1,17 @@
-import { createBlockSignal } from '@core/block';
import { DEV_MODE_ENV } from '@core/constant/featureFlags';
import { copiedItem } from '@core/state/clipboard';
import { unwrap } from 'solid-js/store';
import { OPERATION_LOGGING, Tools } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import type { ImageNode, VideoNode } from '../model/CanvasModel';
import { useCanvasHistory } from '../signal/canvasHistory';
import { useToolManager } from '../signal/toolManager';
-import { highestOrderSignal, useCanvasNodes } from '../store/canvasData';
+import { useCanvasNodes } from '../store/canvasData';
import { useRenderState } from '../store/RenderState';
import { sharedInstance } from '../util/sharedInstance';
import type { Vector2 } from '../util/vector2';
import type { Operation, Operator } from './operation';
-export const selectedImageSignal = createBlockSignal<{
- type: 'image' | 'video';
- id: string;
-}>();
const minSize = 1;
function _log(message: string) {
@@ -29,19 +25,17 @@ export type ImageOperation = Operation & {
node: ImageNode | VideoNode;
};
-export const currentImageOperationSignal = createBlockSignal<ImageOperation>();
-
export const useImage = sharedInstance((): Operator => {
+ const state = useCanvasDocument().state.signals;
const { pageToCanvas } = useRenderState();
const { createNode, updateNode, ...nodes } = useCanvasNodes();
const [currentImageOperation, setCurrentImageOperation] =
- currentImageOperationSignal;
+ useCanvasDocument().state.signals.currentImageOperation;
const { setSelectedTool } = useToolManager();
const history = useCanvasHistory();
- const highestOrder = highestOrderSignal.get;
+ const [highestOrder] = state.highestOrder;
- const selectedImage = selectedImageSignal.get;
- const setSelectedImage = selectedImageSignal.set;
+ const [selectedImage, setSelectedImage] = state.selectedImage;
function _applyMousePos(mousePos: Vector2) {
const op = currentImageOperation();
diff --git a/apps/web/src/features/block-canvas/operation/move.ts b/apps/web/src/features/block-canvas/operation/move.ts
index a4b1fb44f5..9b2e9edf7a 100644
--- a/apps/web/src/features/block-canvas/operation/move.ts
+++ b/apps/web/src/features/block-canvas/operation/move.ts
@@ -1,7 +1,7 @@
-import { createBlockSignal } from '@core/block';
import { DEV_MODE_ENV } from '@core/constant/featureFlags';
import { batch, untrack } from 'solid-js';
import { OPERATION_LOGGING, Tools } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import { useCanvasHistory } from '../signal/canvasHistory';
import { useSelection } from '../signal/selection';
import { useToolManager } from '../signal/toolManager';
@@ -23,11 +23,9 @@ export type MoveOperation = Operation & {
edgePositions: Record<string, { from?: Vector2; to?: Vector2 }>;
};
-export const currentMoveOperationSignal = createBlockSignal<MoveOperation>();
-
export const useMove = sharedInstance((): Operator => {
const [currentMoveOperation, setCurrentMoveOperation] =
- currentMoveOperationSignal;
+ useCanvasDocument().state.signals.currentMoveOperation;
const { selectedNodes, selectedEdges } = useSelection();
const { pageToCanvas } = useRenderState();
const { updateNode, ...nodes } = useCanvasNodes();
diff --git a/apps/web/src/features/block-canvas/operation/pencil.ts b/apps/web/src/features/block-canvas/operation/pencil.ts
index 1301cacc37..17005d1982 100644
--- a/apps/web/src/features/block-canvas/operation/pencil.ts
+++ b/apps/web/src/features/block-canvas/operation/pencil.ts
@@ -1,12 +1,12 @@
-import { createBlockSignal } from '@core/block';
import { DEV_MODE_ENV } from '@core/constant/featureFlags';
import { unwrap } from 'solid-js/store';
import { OPERATION_LOGGING } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import type { PencilNode } from '../model/CanvasModel';
import { useCachedStyle } from '../signal/cachedStyle';
import { useCanvasHistory } from '../signal/canvasHistory';
import { useSelection } from '../signal/selection';
-import { highestOrderSignal, useCanvasNodes } from '../store/canvasData';
+import { useCanvasNodes } from '../store/canvasData';
import { useRenderState } from '../store/RenderState';
import { sharedInstance } from '../util/sharedInstance';
import { simplify } from '../util/simplify';
@@ -31,9 +31,6 @@ function cleanUpLine(coords: Coords): [number, number][] {
return simplified.map(({ x, y }) => [x, y]);
}
-export const currentPencilOperationSignal =
- createBlockSignal<PencilOperation>();
-
export const usePencil = sharedInstance((): Operator => {
const { pageToCanvas } = useRenderState();
const { deselectNode } = useSelection();
@@ -41,8 +38,8 @@ export const usePencil = sharedInstance((): Operator => {
const history = useCanvasHistory();
const cachedStyle = useCachedStyle();
const [currentPencilOperation, setCurrentPencilOperation] =
- currentPencilOperationSignal;
- const highestOrder = highestOrderSignal.get;
+ useCanvasDocument().state.signals.currentPencilOperation;
+ const highestOrder = useCanvasDocument().state.signals.highestOrder[0];
function _calculateDimensions(coords: [number, number][]) {
let minX = Infinity;
diff --git a/apps/web/src/features/block-canvas/operation/rescale.ts b/apps/web/src/features/block-canvas/operation/rescale.ts
index 3f34df9962..1d63bf4290 100644
--- a/apps/web/src/features/block-canvas/operation/rescale.ts
+++ b/apps/web/src/features/block-canvas/operation/rescale.ts
@@ -1,8 +1,8 @@
-import { createBlockSignal } from '@core/block';
import { DEV_MODE_ENV } from '@core/constant/featureFlags';
import { pressedKeys } from '@core/hotkey/state';
import { batch, untrack } from 'solid-js';
import { type Anchor, OPERATION_LOGGING, Tools } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import {
type CanvasEdge,
type CanvasId,
@@ -50,9 +50,6 @@ export type RescaleOperation = {
proportionalDefault: boolean;
};
-export const currentRescaleOperationSignal =
- createBlockSignal<RescaleOperation>();
-
type CoordTuple = [number, number];
type RescaleNodeFunction<T extends CanvasNode> = (
@@ -200,7 +197,7 @@ export const useRescale = sharedInstance((): Operator => {
const { setSelectedTool } = useToolManager();
const history = useCanvasHistory();
const [currentRescaleOperation, setCurrentRescaleOperation] =
- currentRescaleOperationSignal;
+ useCanvasDocument().state.signals.currentRescaleOperation;
const saveCanvasData = useSaveCanvasData();
function applyMousePos(mousePos: Vector2, normalize?: boolean) {
diff --git a/apps/web/src/features/block-canvas/operation/select.ts b/apps/web/src/features/block-canvas/operation/select.ts
index 7ae71d0a93..bef73bfa96 100644
--- a/apps/web/src/features/block-canvas/operation/select.ts
+++ b/apps/web/src/features/block-canvas/operation/select.ts
@@ -1,7 +1,7 @@
import { edgeToCollisionData } from '@block-canvas/util/connectors';
-import { createBlockSignal } from '@core/block';
import { DEV_MODE_ENV } from '@core/constant/featureFlags';
import { OPERATION_LOGGING } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import type { CanvasId, PencilNode } from '../model/CanvasModel';
import { useSelection } from '../signal/selection';
import { useToolManager } from '../signal/toolManager';
@@ -29,13 +29,11 @@ export type SelectOperation = Operation & {
initialSelectedEdges: CanvasId[];
};
-export const currentSelectOperationSignal =
- createBlockSignal<SelectOperation>();
-
export const useSelect = sharedInstance((): Operator => {
const { pageToCanvas } = useRenderState();
const { setSelectionBox, forceSetSelection } = useSelection();
- const [currentOperation, setCurrentOperation] = currentSelectOperationSignal;
+ const [currentOperation, setCurrentOperation] =
+ useCanvasDocument().state.signals.currentSelectOperation;
const nodes = useCanvasNodes();
const egdes = useCanvasEdges();
const groups = useCanvasGroups();
diff --git a/apps/web/src/features/block-canvas/operation/shape.ts b/apps/web/src/features/block-canvas/operation/shape.ts
index 9c745f4175..f95f4e000c 100644
--- a/apps/web/src/features/block-canvas/operation/shape.ts
+++ b/apps/web/src/features/block-canvas/operation/shape.ts
@@ -1,13 +1,13 @@
-import { createBlockSignal } from '@core/block';
import { DEV_MODE_ENV } from '@core/constant/featureFlags';
import { unwrap } from 'solid-js/store';
import { OPERATION_LOGGING, Tools } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import type { ShapeNode } from '../model/CanvasModel';
import { useCachedStyle } from '../signal/cachedStyle';
import { useCanvasHistory } from '../signal/canvasHistory';
import { useSelection } from '../signal/selection';
import { useToolManager } from '../signal/toolManager';
-import { highestOrderSignal, useCanvasNodes } from '../store/canvasData';
+import { useCanvasNodes } from '../store/canvasData';
import { useRenderState } from '../store/RenderState';
import { sharedInstance } from '../util/sharedInstance';
import type { Vector2 } from '../util/vector2';
@@ -26,18 +26,16 @@ export type ShapeOperation = Operation & {
node: ShapeNode;
};
-export const currentShapeOperationSignal = createBlockSignal<ShapeOperation>();
-
export const useShape = sharedInstance((): Operator => {
const { pageToCanvas } = useRenderState();
const { createNode, updateNode, ...nodes } = useCanvasNodes();
const { deselectAll, deselectNode } = useSelection();
const [currentShapeOperation, setCurrentShapeOperation] =
- currentShapeOperationSignal;
+ useCanvasDocument().state.signals.currentShapeOperation;
const history = useCanvasHistory();
const cachedStyle = useCachedStyle();
const { setSelectedTool } = useToolManager();
- const highestOrder = highestOrderSignal.get;
+ const highestOrder = useCanvasDocument().state.signals.highestOrder[0];
function _applyMousePos(mousePos: Vector2, normalize?: boolean) {
const op = currentShapeOperation();
diff --git a/apps/web/src/features/block-canvas/operation/text.ts b/apps/web/src/features/block-canvas/operation/text.ts
index 12daad93c5..e82145608b 100644
--- a/apps/web/src/features/block-canvas/operation/text.ts
+++ b/apps/web/src/features/block-canvas/operation/text.ts
@@ -1,13 +1,13 @@
-import { createBlockSignal } from '@core/block';
import { DEV_MODE_ENV } from '@core/constant/featureFlags';
import { batch } from 'solid-js';
import { unwrap } from 'solid-js/store';
import { OPERATION_LOGGING } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import type { TextNode } from '../model/CanvasModel';
import { useCachedStyle } from '../signal/cachedStyle';
import { useCanvasHistory } from '../signal/canvasHistory';
import { useSelection } from '../signal/selection';
-import { highestOrderSignal, useCanvasNodes } from '../store/canvasData';
+import { useCanvasNodes } from '../store/canvasData';
import { useRenderState } from '../store/RenderState';
import { sharedInstance } from '../util/sharedInstance';
import type { Vector2 } from '../util/vector2';
@@ -24,17 +24,15 @@ export type TextOperation = Operation & {
node: TextNode;
};
-export const currentTextOperationSignal = createBlockSignal<TextOperation>();
-
export const useText = sharedInstance((): Operator => {
const { pageToCanvas } = useRenderState();
const { createNode, updateNode, ...nodes } = useCanvasNodes();
const { deselectNode } = useSelection();
const [currentTextOperation, setCurrentTextOperation] =
- currentTextOperationSignal;
+ useCanvasDocument().state.signals.currentTextOperation;
const history = useCanvasHistory();
const cachedStyle = useCachedStyle();
- const highestOrder = highestOrderSignal.get;
+ const highestOrder = useCanvasDocument().state.signals.highestOrder[0];
function _applyMousePos(mousePos: Vector2, normalize?: boolean) {
const op = currentTextOperation();
diff --git a/apps/web/src/features/block-canvas/queries/canvas-document.test.ts b/apps/web/src/features/block-canvas/queries/canvas-document.test.ts
new file mode 100644
index 0000000000..8f85f15e7c
--- /dev/null
+++ b/apps/web/src/features/block-canvas/queries/canvas-document.test.ts
@@ -0,0 +1,57 @@
+import { ok } from 'neverthrow';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { fetchCanvasViewLocation, saveCanvasDocument } from './canvas-document';
+
+const storageMocks = vi.hoisted(() => ({
+ getDocumentMetadata: vi.fn(),
+ simpleSave: vi.fn(),
+}));
+
+vi.mock('@service-storage/client', () => ({
+ storageServiceClient: storageMocks,
+}));
+
+describe('canvas document queries', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('parses the persisted canvas view location', async () => {
+ storageMocks.getDocumentMetadata.mockResolvedValue(
+ ok({ viewLocation: '#x=12&y=-8&s=125' })
+ );
+
+ await expect(fetchCanvasViewLocation('canvas-1')).resolves.toEqual({
+ x: 12,
+ y: -8,
+ scale: 125,
+ });
+ });
+
+ it('serializes canvas data for storage', async () => {
+ storageMocks.simpleSave.mockResolvedValue(ok({}));
+ const canvas = {
+ nodes: [],
+ edges: [],
+ groups: [],
+ };
+
+ const result = await saveCanvasDocument('canvas-1', canvas);
+
+ expect(result.saved).toBe(true);
+ expect(storageMocks.simpleSave).toHaveBeenCalledWith({
+ documentId: 'canvas-1',
+ file: result.file,
+ });
+ expect(await readBlob(result.file)).toBe(JSON.stringify(canvas));
+ });
+});
+
+function readBlob(blob: Blob) {
+ return new Promise<string>((resolve, reject) => {
+ const reader = new FileReader();
+ reader.addEventListener('load', () => resolve(String(reader.result)));
+ reader.addEventListener('error', () => reject(reader.error));
+ reader.readAsText(blob);
+ });
+}
diff --git a/apps/web/src/features/block-canvas/queries/canvas-document.ts b/apps/web/src/features/block-canvas/queries/canvas-document.ts
new file mode 100644
index 0000000000..cdf46da2f1
--- /dev/null
+++ b/apps/web/src/features/block-canvas/queries/canvas-document.ts
@@ -0,0 +1,73 @@
+import { storageServiceClient } from '@service-storage/client';
+import type { Canvas } from '../model/CanvasModel';
+
+export type CanvasViewLocation = {
+ x?: number;
+ y?: number;
+ scale?: number;
+};
+
+export async function fetchCanvasViewLocation(
+ documentId: string
+): Promise<CanvasViewLocation | null> {
+ const result = await storageServiceClient.getDocumentMetadata({
+ documentId,
+ init: {
+ signal: AbortSignal.timeout(3000),
+ },
+ });
+ if (result.isErr()) return null;
+
+ const { viewLocation } = result.value;
+ if (!viewLocation) return null;
+
+ const params = new URLSearchParams(viewLocation.replace('#', ''));
+ return {
+ x: numberOrUndefined(params.get('x')),
+ y: numberOrUndefined(params.get('y')),
+ scale: numberOrUndefined(params.get('s')),
+ };
+}
+
+export async function saveCanvasDocument(
+ documentId: string,
+ canvas: Canvas
+): Promise<{ file: Blob; saved: boolean }> {
+ const buffer = new TextEncoder().encode(JSON.stringify(canvas));
+ const file = new Blob([buffer], {
+ type: 'application/x-macro-canvas',
+ });
+ const result = await storageServiceClient.simpleSave({
+ documentId,
+ file,
+ });
+ return { file, saved: result.isOk() };
+}
+
+export async function saveCanvasViewLocation(
+ documentId: string,
+ state: { x: number; y: number; scale: number }
+) {
+ if (
+ Number.isNaN(state.x) ||
+ Number.isNaN(state.y) ||
+ Number.isNaN(state.scale)
+ ) {
+ return;
+ }
+
+ await storageServiceClient.upsertDocumentViewLocation({
+ documentId,
+ location:
+ (state.x !== 0 ? `#x=${Math.round(state.x)}` : '') +
+ (state.y !== 0 ? `&y=${Math.round(state.y)}` : '') +
+ (state.scale !== 1 ? `&s=${Math.round(state.scale * 100)}` : ''),
+ });
+}
+
+function numberOrUndefined(
+ value: string | undefined | null
+): number | undefined {
+ const number = Number(value);
+ return value == null || Number.isNaN(number) ? undefined : number;
+}
diff --git a/apps/web/src/features/block-canvas/signal/cachedStyle.ts b/apps/web/src/features/block-canvas/signal/cachedStyle.ts
index bb8cf8984b..a2681950bc 100644
--- a/apps/web/src/features/block-canvas/signal/cachedStyle.ts
+++ b/apps/web/src/features/block-canvas/signal/cachedStyle.ts
@@ -1,25 +1,9 @@
-import { createBlockStore } from '@core/block';
import { createMemo } from 'solid-js';
-import {
- type CanvasEntityStyle,
- EdgeConnectionStyles,
-} from '../model/CanvasModel';
-import { getTailwindColor } from '../util/style';
-
-const defaultStyle: () => CanvasEntityStyle = () => ({
- fillColor: getTailwindColor('neutral-100'),
- strokeColor: getTailwindColor('neutral-700'),
- strokeWidth: 2,
- cornerRadius: 0,
- opacity: 1,
- textSize: 16,
- connectionStyle: EdgeConnectionStyles.straight,
-});
-
-const cachedStyle = createBlockStore<CanvasEntityStyle>(defaultStyle());
+import { useCanvasDocument } from '../context/canvas-document-context';
+import type { CanvasEntityStyle } from '../model/CanvasModel';
export function useCachedStyle() {
- const [style, setStyle] = cachedStyle;
+ const [style, setStyle] = useCanvasDocument().state.stores.cachedStyle;
return {
getStyle: createMemo(() => JSON.parse(JSON.stringify(style))),
setProp: (prop: keyof CanvasEntityStyle, value: any) => {
diff --git a/apps/web/src/features/block-canvas/signal/canvasBlockData.ts b/apps/web/src/features/block-canvas/signal/canvasBlockData.ts
deleted file mode 100644
index b5bcb12a7e..0000000000
--- a/apps/web/src/features/block-canvas/signal/canvasBlockData.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import { blockDataSignalAs } from '@core/block';
-import type { CanvasData } from '../definition';
-
-export const blockDataSignal = blockDataSignalAs<CanvasData>('canvas');
diff --git a/apps/web/src/features/block-canvas/signal/canvasHistory.ts b/apps/web/src/features/block-canvas/signal/canvasHistory.ts
index 28590778da..ede5da5ba7 100644
--- a/apps/web/src/features/block-canvas/signal/canvasHistory.ts
+++ b/apps/web/src/features/block-canvas/signal/canvasHistory.ts
@@ -1,8 +1,7 @@
-import { edgesStore, nodesStore } from '@block-canvas/store/nodesStore';
import { sharedInstance } from '@block-canvas/util/sharedInstance';
-import { createBlockSignal } from '@core/block';
import { batch, untrack } from 'solid-js';
import { reconcile, unwrap } from 'solid-js/store';
+import { useCanvasDocument } from '../context/canvas-document-context';
import type { CanvasEdge, CanvasId, CanvasNode } from '../model/CanvasModel';
import {
renderQueue,
@@ -12,7 +11,7 @@ import {
import type { Renderable } from '../util/renderQueue';
import { useSelection } from './selection';
-type Snapshot = {
+export type Snapshot = {
renderQueue: Renderable[];
allNodes: Record<CanvasId, CanvasNode>;
allEdges: Record<string, CanvasEdge>;
@@ -22,21 +21,20 @@ type Snapshot = {
};
const MAX_HISTORY_LENGTH = 40;
-const historySignal = createBlockSignal<Snapshot[]>([]);
-const currentHistorySignal = createBlockSignal<Snapshot | undefined>(undefined);
-const currentStateIndex = createBlockSignal<number>(-1);
export const useCanvasHistory = sharedInstance(createHistory);
function createHistory() {
+ const canvasState = useCanvasDocument().state;
+ const state = canvasState.signals;
const nodes = useCanvasNodes();
const edges = useCanvasEdges();
const selection = useSelection();
- const [history, setHistory] = historySignal;
- const [current, setCurrent] = currentHistorySignal;
- const [currentIndex, setCurrentIndex] = currentStateIndex;
- const [allNodes, setNodeStore] = nodesStore;
- const [allEdges, setEdgeStore] = edgesStore;
+ const [history, setHistory] = state.history;
+ const [current, setCurrent] = state.currentHistory;
+ const [currentIndex, setCurrentIndex] = state.currentHistoryIndex;
+ const [allNodes, setNodeStore] = canvasState.stores.nodes;
+ const [allEdges, setEdgeStore] = canvasState.stores.edges;
const queue = renderQueue();
function createSnapshot(): Snapshot {
diff --git a/apps/web/src/features/block-canvas/signal/clipboard.ts b/apps/web/src/features/block-canvas/signal/clipboard.ts
index 17aa5de9b8..d494a8e584 100644
--- a/apps/web/src/features/block-canvas/signal/clipboard.ts
+++ b/apps/web/src/features/block-canvas/signal/clipboard.ts
@@ -6,6 +6,7 @@ import { blockNameToFileExtensions } from '@core/constant/allBlocks';
import { CANVAS_SVG_IMPORT } from '@core/constant/featureFlags';
import { nanoid } from 'nanoid';
import { batch } from 'solid-js';
+import { useCanvasDocument } from '../context/canvas-document-context';
import {
type Canvas,
type CanvasEdge,
@@ -13,7 +14,6 @@ import {
CanvasSchema,
} from '../model/CanvasModel';
import {
- highestOrderSignal,
useBoundingBox,
useCanvasEdges,
useCanvasGroups,
@@ -39,7 +39,7 @@ export const useClipboard = sharedInstance(() => {
const nodes = useCanvasNodes();
const edges = useCanvasEdges();
const groups = useCanvasGroups();
- const highestOrder = highestOrderSignal.get;
+ const highestOrder = useCanvasDocument().state.signals.highestOrder[0];
const history = useCanvasHistory();
const { staticImageUpload, parseSVGStringToNodes } = useCanvasFileDrop();
const boundingBox = useBoundingBox();
diff --git a/apps/web/src/features/block-canvas/signal/fileDrop.ts b/apps/web/src/features/block-canvas/signal/fileDrop.ts
index bf79b5177f..b45fd7a12a 100644
--- a/apps/web/src/features/block-canvas/signal/fileDrop.ts
+++ b/apps/web/src/features/block-canvas/signal/fileDrop.ts
@@ -4,10 +4,7 @@ import type {
CanvasEntityStyle,
ShapeType,
} from '@block-canvas/model/CanvasModel';
-import {
- highestOrderSignal,
- useCanvasNodes,
-} from '@block-canvas/store/canvasData';
+import { useCanvasNodes } from '@block-canvas/store/canvasData';
import { useRenderState } from '@block-canvas/store/RenderState';
import {
parseScale,
@@ -15,25 +12,23 @@ import {
svgEntityStyles,
} from '@block-canvas/util/svg';
import { type Vector2, vec2 } from '@block-canvas/util/vector2';
-import { createBlockSignal } from '@core/block';
import { toast } from '@core/component/Toast/Toast';
import { CANVAS_SVG_IMPORT } from '@core/constant/featureFlags';
import { uploadFile } from '@core/util/upload';
import { nanoid } from 'nanoid';
import { createSignal } from 'solid-js';
+import { useCanvasDocument } from '../context/canvas-document-context';
import { getTextNodeHeight } from '../util/style';
import { useCachedStyle } from './cachedStyle';
import { useCanvasHistory } from './canvasHistory';
import { useToolManager } from './toolManager';
-export const canvasDraggingSignal = createBlockSignal(false);
-
export const useCanvasFileDrop = () => {
const [fileDropPos, setFileDropPos] = createSignal(vec2(0, 0));
const { clientToCanvas } = useRenderState();
const nodes = useCanvasNodes();
const { setSelectedTool } = useToolManager();
- const highestOrder = highestOrderSignal.get;
+ const highestOrder = useCanvasDocument().state.signals.highestOrder[0];
const history = useCanvasHistory();
const cachedStyle = useCachedStyle();
diff --git a/apps/web/src/features/block-canvas/signal/selection.ts b/apps/web/src/features/block-canvas/signal/selection.ts
index 7492b62786..bbae25bf7f 100644
--- a/apps/web/src/features/block-canvas/signal/selection.ts
+++ b/apps/web/src/features/block-canvas/signal/selection.ts
@@ -4,8 +4,8 @@ import {
useGetGroup,
useGetNode,
} from '@block-canvas/store/getNodeEdge';
-import { createBlockSignal } from '@core/block';
import { createMemo, untrack } from 'solid-js';
+import { useCanvasDocument } from '../context/canvas-document-context';
import {
type CanvasEdge,
type CanvasEntityStyle,
@@ -16,26 +16,20 @@ import {
import type { Rectangle } from '../util/rectangle';
import { sharedInstance } from '../util/sharedInstance';
-export const selectedNodeIdsSignal = createBlockSignal<Set<string>>(new Set());
-export const selectedEdgeIdsSignal = createBlockSignal<Set<string>>(new Set());
-export const selectedGroupIdsSignal = createBlockSignal<Set<string>>(new Set());
-export const boxSelectionSignal = createBlockSignal<Rectangle>();
-const lastSelectedNodeIdsSignal = createBlockSignal<Set<string>>(new Set());
-const lastSelectedEdgeIdsSignal = createBlockSignal<Set<string>>(new Set());
-
export type Selection = ReturnType<typeof createSelection>;
export const useSelection = sharedInstance<Selection>(createSelection);
function createSelection() {
- const [selectedNodeIds, setSelectedNodeIds] = selectedNodeIdsSignal;
- const [selectedEdgeIds, setSelectedEdgeIds] = selectedEdgeIdsSignal;
- const [selectedGroupIds, setSelectedGroupIds] = selectedGroupIdsSignal;
+ const state = useCanvasDocument().state.signals;
+ const [selectedNodeIds, setSelectedNodeIds] = state.selectedNodeIds;
+ const [selectedEdgeIds, setSelectedEdgeIds] = state.selectedEdgeIds;
+ const [selectedGroupIds, setSelectedGroupIds] = state.selectedGroupIds;
const [lastSelectedNodeIds, setLastSelectedNodeIds] =
- lastSelectedNodeIdsSignal;
+ state.lastSelectedNodeIds;
const [lastSelectedEdgeIds, setLastSelectedEdgeIds] =
- lastSelectedEdgeIdsSignal;
- const [boxSelection, setBoxSelection] = boxSelectionSignal;
+ state.lastSelectedEdgeIds;
+ const [boxSelection, setBoxSelection] = state.selectionBox;
const getNode = useGetNode();
const getEdge = useGetEdge();
const getGroup = useGetGroup();
diff --git a/apps/web/src/features/block-canvas/signal/toolManager.ts b/apps/web/src/features/block-canvas/signal/toolManager.ts
index c7c14b2d9a..cbaaa94973 100644
--- a/apps/web/src/features/block-canvas/signal/toolManager.ts
+++ b/apps/web/src/features/block-canvas/signal/toolManager.ts
@@ -1,17 +1,15 @@
-import { contextMenuStore } from '@block-canvas/component/ContextMenu';
import { clamp, lerp, remap } from '@block-canvas/util/math';
import { getTextNodeHeight } from '@block-canvas/util/style';
-import { createBlockSignal, useIsNestedBlock } from '@core/block';
import { IS_MAC } from '@core/constant/isMac';
import { pressedKeys } from '@core/hotkey/state';
-import { useCanEdit } from '@core/signal/permissions';
import { isEditableInput } from '@core/util/isEditableInput';
import { createCallback } from '@solid-primitives/rootless';
import { nanoid } from 'nanoid';
import { createMemo, createSignal } from 'solid-js';
import { DRAG_THRESHOLD, type Tool, Tools, ViewOnlyTools } from '../constants';
+import { useCanvasDocument } from '../context/canvas-document-context';
import type { Operator } from '../operation/operation';
-import { highestOrderSignal, useCanvasNodes } from '../store/canvasData';
+import { useCanvasNodes } from '../store/canvasData';
import { useRenderState } from '../store/RenderState';
import { sharedInstance } from '../util/sharedInstance';
import { type Vector2, vec2 } from '../util/vector2';
@@ -26,42 +24,27 @@ export type DispatchMouseArgs = {
args: any[];
};
-export const selectedToolSignal = createBlockSignal<Tool>(Tools.Grab);
-export const pressedModifiersSignal = createBlockSignal<Set<string>>(new Set());
-
-export const handlersByToolSignal = createBlockSignal<Map<Tool, Operator[]>>(
- new Map()
-);
-
-export const mouseDownPositionSignal = createBlockSignal<Vector2>();
-export const mousePositionSignal = createBlockSignal<Vector2>();
-export const lastMousePositionSignal = createBlockSignal<Vector2>();
-export const rawMouseDownPositionSignal = createBlockSignal<Vector2>();
-export const activeTextEditorSignal = createBlockSignal<boolean>(false);
-
-export const middleMousePressedSignal = createBlockSignal<boolean>();
-export const rightMousePressedSignal = createBlockSignal<boolean>();
-
export const useToolManager = sharedInstance<ToolManager>(createToolManager);
function createToolManager() {
- const canEdit = useCanEdit();
- const isNestedBlock = useIsNestedBlock();
- const [selectedTool, setTool] = selectedToolSignal;
- const [mouseDownPos, setMouseDownPos] = mouseDownPositionSignal;
- const [handlersByTool, setHandlersByTool] = handlersByToolSignal;
- const [middleMousePressed, setMiddleMousePressed] = middleMousePressedSignal;
- const [mousePosition, setMousePosition] = mousePositionSignal;
- const [lastMousePosition, setLastMousePosition] = lastMousePositionSignal;
- const [rawMouseDownPos, setRawMouseDownPos] = rawMouseDownPositionSignal;
+ const canvas = useCanvasDocument();
+ const { canEdit, isNested } = canvas;
+ const state = canvas.state.signals;
+ const [selectedTool, setTool] = state.selectedTool;
+ const [mouseDownPos, setMouseDownPos] = state.mouseDownPosition;
+ const [handlersByTool, setHandlersByTool] = state.handlersByTool;
+ const [middleMousePressed, setMiddleMousePressed] = state.middleMousePressed;
+ const [mousePosition, setMousePosition] = state.mousePosition;
+ const [lastMousePosition, setLastMousePosition] = state.lastMousePosition;
+ const [rawMouseDownPos, setRawMouseDownPos] = state.rawMouseDownPosition;
const [isDragging, setIsDragging] = createSignal(false);
- const [activeTextEditor, setActiveTextEditor] = activeTextEditorSignal;
+ const [activeTextEditor, setActiveTextEditor] = state.activeTextEditor;
const [_previousTouch, setPreviousTouch] = createSignal<Vector2>();
const { clientToCanvas, zoom, pan } = useRenderState();
const selection = useSelection();
const history = useCanvasHistory();
- const highestOrder = highestOrderSignal.get;
+ const [highestOrder] = state.highestOrder;
const ignoreTargets: HTMLElement[] = [];
@@ -120,7 +103,7 @@ function createToolManager() {
setPreviousTouch(currentPos);
}
- const contextMenu = contextMenuStore.get;
+ const [contextMenu] = canvas.state.stores.contextMenu;
function pointerDown(e: PointerEvent) {
if (e.pointerType === 'mouse') {
@@ -348,7 +331,7 @@ function createToolManager() {
// containerRef.addEventListener('pointerenter', pointerEnter);
containerRef.addEventListener('dblclick', dblClick);
- if (!isNestedBlock) {
+ if (!isNested()) {
containerRef.addEventListener('wheel', scroll, { passive: false });
}
},
@@ -361,7 +344,7 @@ function createToolManager() {
// containerRef?.removeEventListener('pointerenter', pointerEnter);
containerRef?.removeEventListener('dblclick', dblClick);
- if (!isNestedBlock) {
+ if (!isNested()) {
containerRef?.removeEventListener('wheel', scroll);
}
},
diff --git a/apps/web/src/features/block-canvas/store/RenderState.ts b/apps/web/src/features/block-canvas/store/RenderState.ts
index 0b9b1d86f1..0998e29b37 100644
--- a/apps/web/src/features/block-canvas/store/RenderState.ts
+++ b/apps/web/src/features/block-canvas/store/RenderState.ts
@@ -1,18 +1,11 @@
import { MAX_ZOOM, MIN_ZOOM } from '@block-canvas/constants';
import { sharedInstance } from '@block-canvas/util/sharedInstance';
-import {
- type BlockStore,
- createBlockEffect,
- createBlockMemo,
- createBlockStore,
- useBlockId,
- useIsNestedBlock,
-} from '@core/block';
-import { storageServiceClient } from '@service-storage/client';
import { createCallback } from '@solid-primitives/rootless';
import { debounce } from '@solid-primitives/scheduled';
import { createEffect, createSignal } from 'solid-js';
import { unwrap } from 'solid-js/store';
+import { useCanvasDocument } from '../context/canvas-document-context';
+import { saveCanvasViewLocation } from '../queries/canvas-document';
import { clamp, easeInOutCubic } from '../util/math';
import { Rect } from '../util/rectangle';
import { vec2 } from '../util/vector2';
@@ -31,86 +24,46 @@ export const defaultRenderState = (): RenderState => ({
containerRect: undefined,
});
-export const renderStateStore: BlockStore<RenderState> = createBlockStore(
- defaultRenderState()
-);
-
-type AnimationState = {
- startX: number;
- startY: number;
- startScale: number;
- targetX: number;
- targetY: number;
- targetScale: number;
- startTime: number;
- duration: number;
- isAnimating: boolean;
-};
-
-// Create a block store for animation state
-const animationStore = createBlockStore<AnimationState>({
- startX: 0,
- startY: 0,
- startScale: 1,
- targetX: 0,
- targetY: 0,
- targetScale: 1,
- startTime: 0,
- duration: 0,
- isAnimating: false,
-});
-
-export const isAnimating = createBlockMemo(
- () => animationStore.get.isAnimating
-);
-
-// Create block effect for animation handling
-createBlockEffect(() => {
- const [animation, setAnimation] = animationStore;
- const [, setState] = renderStateStore;
- if (!animation.isAnimating) return;
-
- const animate = () => {
- const now = performance.now();
- const elapsed = now - animation.startTime;
- const progress = Math.min(elapsed / animation.duration, 1);
-
- // Apply easing
- // const t = easeInOutCubic(progress);
- const t = easeInOutCubic(progress);
-
- // Interpolate values
- const x = animation.startX + (animation.targetX - animation.startX) * t;
- const y = animation.startY + (animation.targetY - animation.startY) * t;
- const scale =
- animation.startScale + (animation.targetScale - animation.startScale) * t;
-
- setState({ x, y, scale });
-
- if (progress < 1) {
- requestAnimationFrame(animate);
- } else {
- setAnimation('isAnimating', false);
- }
- };
-
- requestAnimationFrame(animate);
-});
-
/**
- * Modify and read the canvas's render state from a block-scoped closure
+ * Modify and read the canvas's render state from its document-scoped context
* (usually the top level of a component or a createCallback called from the top
* level of a component).
*/
export const useRenderState = sharedInstance(() => {
- const [state, setState] = renderStateStore;
- const [, setAnimation] = animationStore;
- const blockId = useBlockId();
- const isNestedBlock = useIsNestedBlock();
+ const canvas = useCanvasDocument();
+ const [state, setState] = canvas.state.stores.render;
+ const [animation, setAnimation] = canvas.state.stores.animation;
+ const { documentId, isNested } = canvas;
+
+ createEffect(() => {
+ if (!animation.isAnimating) return;
+
+ const animate = () => {
+ const now = performance.now();
+ const elapsed = now - animation.startTime;
+ const progress = Math.min(elapsed / animation.duration, 1);
+ const t = easeInOutCubic(progress);
+ const x = animation.startX + (animation.targetX - animation.startX) * t;
+ const y = animation.startY + (animation.targetY - animation.startY) * t;
+ const scale =
+ animation.startScale +
+ (animation.targetScale - animation.startScale) * t;
+
+ setState({ x, y, scale });
+
+ if (progress < 1) {
+ requestAnimationFrame(animate);
+ } else {
+ setAnimation('isAnimating', false);
+ }
+ };
+
+ requestAnimationFrame(animate);
+ });
const debouncedSaveState = debounce(() => {
- if (isNestedBlock) return;
- saveState(blockId, unwrap(state));
+ if (isNested()) return;
+ void saveCanvasViewLocation(documentId(), unwrap(state));
}, 500);
const [defferedScale, setDeferredScale] = createSignal(state.scale);
@@ -344,19 +297,3 @@ export const useRenderState = sharedInstance(() => {
},
};
});
-
-async function saveState(
- blockId: string,
- state: { x: number; y: number; scale: number }
-) {
- if (isNaN(state.x) || isNaN(state.y) || isNaN(state.scale)) {
- return;
- }
- await storageServiceClient.upsertDocumentViewLocation({
- documentId: blockId,
- location:
- (state.x !== 0 ? '#x=' + Math.round(state.x) : '') +
- (state.y !== 0 ? '&y=' + Math.round(state.y) : '') +
- (state.scale !== 1 ? '&s=' + Math.round(state.scale * 100) : ''),
- });
-}
diff --git a/apps/web/src/features/block-canvas/store/canvasData.ts b/apps/web/src/features/block-canvas/store/canvasData.ts
index cdde2919de..4163feaa32 100644
--- a/apps/web/src/features/block-canvas/store/canvasData.ts
+++ b/apps/web/src/features/block-canvas/store/canvasData.ts
@@ -2,14 +2,13 @@ import {
edgeToCollisionData,
getEdgeEndVectors,
} from '@block-canvas/util/connectors';
-import { createBlockSignal, useBlockId } from '@core/block';
import { filterMapAsync } from '@core/util/list';
-import { storageServiceClient } from '@service-storage/client';
import { createCallback } from '@solid-primitives/rootless';
import { debounce } from '@solid-primitives/scheduled';
import { nanoid } from 'nanoid';
import { batch, createMemo } from 'solid-js';
+import { useCanvasDocument } from '../context/canvas-document-context';
import {
type Canvas,
type CanvasEdge,
@@ -22,7 +21,7 @@ import {
NodeSchema,
type PencilNode,
} from '../model/CanvasModel';
-import { blockDataSignal } from '../signal/canvasBlockData';
+import { saveCanvasDocument } from '../queries/canvas-document';
import { useSelection } from '../signal/selection';
import { untrackMentionsInTextNode } from '../util/mentions';
import { Rect, type Rectangle } from '../util/rectangle';
@@ -30,32 +29,40 @@ import { createRenderQueue } from '../util/renderQueue';
import { sharedInstance } from '../util/sharedInstance';
import { type Vector2, vec2 } from '../util/vector2';
import { useGetEdge, useGetGroup, useGetNode } from './getNodeEdge';
-import { edgesStore, groupStore, nodesStore } from './nodesStore';
export const renderQueue = sharedInstance(() => {
- return createRenderQueue(nodesStore, edgesStore, groupStore);
+ const state = useCanvasDocument().state;
+ return createRenderQueue(
+ state.stores.nodes,
+ state.stores.edges,
+ state.stores.groups,
+ state.signals.highestOrder[1]
+ );
});
export const previewRenderQueue = sharedInstance(() => {
- return createRenderQueue(nodesStore, edgesStore, groupStore);
+ const state = useCanvasDocument().state;
+ return createRenderQueue(
+ state.stores.nodes,
+ state.stores.edges,
+ state.stores.groups,
+ state.signals.highestOrder[1]
+ );
});
export const debugRenderQueue = sharedInstance(() => {
- return createRenderQueue(nodesStore, edgesStore, groupStore);
+ const state = useCanvasDocument().state;
+ return createRenderQueue(
+ state.stores.nodes,
+ state.stores.edges,
+ state.stores.groups,
+ state.signals.highestOrder[1]
+ );
});
-export const highestOrderSignal = createBlockSignal<number>(0);
-
-const lastCreatedNodeId = createBlockSignal<CanvasId>();
-
// TODO (seamus) : This pending updates thing is a stop gap until the save logic
// is refined and integrated into undo/redo system.
// Since it's a temp. solution, I've left it as a shared signal between nodes and edges -Ness
-export const pendingUpdates = createBlockSignal(false);
-
-// I really should just update the canvasFile signal as that's the pattern I intend to use for PDF
-// But I'm not sure what kind of effects the derived signal would have so I'll just play it safe
-export const currentSavedFile = createBlockSignal<Blob | null>(null);
export interface OperationOptions {
autosave?: boolean;
@@ -65,8 +72,9 @@ export interface OperationOptions {
}
export const useSetAllNodes = sharedInstance(() => {
- const [, setStore] = nodesStore;
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setStore] = useCanvasDocument().state.stores.nodes;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
const saveCanvasData = useSaveCanvasData();
const rq = renderQueue();
@@ -83,13 +91,14 @@ export const useSetAllNodes = sharedInstance(() => {
});
export const useDeleteNode = sharedInstance(() => {
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
const saveCanvasData = useSaveCanvasData();
const getNode = useGetNode();
const getEdge = useGetEdge();
const disconnectEdge = useEdgeUtils().disconnectEdge;
const rq = renderQueue();
- const blockId = useBlockId();
+ const blockId = useCanvasDocument().documentId();
const untrackMentionsInTextNode_ = createCallback(untrackMentionsInTextNode);
return createCallback(async (id: CanvasId, opts?: OperationOptions) => {
@@ -114,8 +123,9 @@ export const useDeleteNode = sharedInstance(() => {
});
export const useCreateNode = sharedInstance(() => {
- const [nodes, setStore] = nodesStore;
- const [, setPendingUpdates] = pendingUpdates;
+ const [nodes, setStore] = useCanvasDocument().state.stores.nodes;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
const saveCanvasData = useSaveCanvasData();
const { selectNode, deselectAll } = useSelection();
const rq = renderQueue();
@@ -155,9 +165,10 @@ export const useCreateNode = sharedInstance(() => {
});
export const useUpdateNode = sharedInstance(() => {
- const [store, setStore] = nodesStore;
+ const [store, setStore] = useCanvasDocument().state.stores.nodes;
const saveCanvasData = useSaveCanvasData();
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
return createCallback(
(id: CanvasId, updates: Partial<CanvasNode>, opts?: OperationOptions) => {
@@ -181,8 +192,10 @@ export const useUpdateNode = sharedInstance(() => {
});
export const useCanvasNodes = sharedInstance(() => {
- const [pending, setPending] = pendingUpdates;
- const [lastCreated, setLastCreated] = lastCreatedNodeId;
+ const [pending, setPending] =
+ useCanvasDocument().state.signals.pendingUpdates;
+ const [lastCreated, setLastCreated] =
+ useCanvasDocument().state.signals.lastCreatedNodeId;
const saveCanvasData = useSaveCanvasData();
const getNode = useGetNode();
const rq = renderQueue();
@@ -219,8 +232,9 @@ export const useCanvasNodes = sharedInstance(() => {
});
export const useSetAllEdges = sharedInstance(() => {
- const [, setStore] = edgesStore;
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setStore] = useCanvasDocument().state.stores.edges;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
const saveCanvasData = useSaveCanvasData();
const rq = renderQueue();
@@ -237,7 +251,8 @@ export const useSetAllEdges = sharedInstance(() => {
});
export const useDeleteEdge = sharedInstance(() => {
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
const saveCanvasData = useSaveCanvasData();
const getEdge = useGetEdge();
const getNode = useGetNode();
@@ -271,8 +286,9 @@ export const useDeleteEdge = sharedInstance(() => {
});
export const useCreateEdge = sharedInstance(() => {
- const [, setStore] = edgesStore;
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setStore] = useCanvasDocument().state.stores.edges;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
const saveCanvasData = useSaveCanvasData();
const getNode = useGetNode();
const updateNode = useUpdateNode();
@@ -318,9 +334,10 @@ export const useCreateEdge = sharedInstance(() => {
});
export const useUpdateEdge = sharedInstance(() => {
- const [store, setStore] = edgesStore;
+ const [store, setStore] = useCanvasDocument().state.stores.edges;
const saveCanvasData = useSaveCanvasData();
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
const getEdge = useGetEdge();
const getNode = useGetNode();
const updateNode = useUpdateNode();
@@ -372,7 +389,8 @@ export const useUpdateEdge = sharedInstance(() => {
});
export const useCanvasEdges = sharedInstance(() => {
- const [pending, setPending] = pendingUpdates;
+ const [pending, setPending] =
+ useCanvasDocument().state.signals.pendingUpdates;
const getEdge = useGetEdge();
const saveCanvasData = useSaveCanvasData();
const rq = renderQueue();
@@ -526,8 +544,9 @@ export const useBoundingBox = sharedInstance(() => {
});
export const useSetAllGroups = sharedInstance(() => {
- const [, setStore] = groupStore;
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setStore] = useCanvasDocument().state.stores.groups;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
const saveCanvasData = useSaveCanvasData();
return createCallback((groups: CanvasGroup[], opts?: OperationOptions) => {
@@ -538,7 +557,8 @@ export const useSetAllGroups = sharedInstance(() => {
});
export const useDeleteGroup = sharedInstance(() => {
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
const saveCanvasData = useSaveCanvasData();
const getNode = useGetNode();
const getEdge = useGetEdge();
@@ -578,8 +598,9 @@ export const useDeleteGroup = sharedInstance(() => {
});
export const useCreateGroup = sharedInstance(() => {
- const [groups, setStore] = groupStore;
- const [, setPendingUpdates] = pendingUpdates;
+ const [groups, setStore] = useCanvasDocument().state.stores.groups;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
const saveCanvasData = useSaveCanvasData();
const { selectedNodeIds, selectedEdgeIds, selectedNodes } = useSelection();
const updateNode = useUpdateNode();
@@ -630,9 +651,10 @@ export const useCreateGroup = sharedInstance(() => {
});
export const useUpdateGroup = sharedInstance(() => {
- const [store, setStore] = groupStore;
+ const [store, setStore] = useCanvasDocument().state.stores.groups;
const saveCanvasData = useSaveCanvasData();
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
return createCallback(
(id: CanvasId, updates: Partial<CanvasGroup>, opts?: OperationOptions) => {
@@ -645,9 +667,10 @@ export const useUpdateGroup = sharedInstance(() => {
});
export const useAddNodeToGroup = sharedInstance(() => {
- const [store, setStore] = groupStore;
+ const [store, setStore] = useCanvasDocument().state.stores.groups;
const saveCanvasData = useSaveCanvasData();
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
return createCallback(
(id: CanvasId, nodeId: string, opts?: OperationOptions) => {
@@ -661,9 +684,10 @@ export const useAddNodeToGroup = sharedInstance(() => {
});
export const useAddEdgeToGroup = sharedInstance(() => {
- const [store, setStore] = groupStore;
+ const [store, setStore] = useCanvasDocument().state.stores.groups;
const saveCanvasData = useSaveCanvasData();
- const [, setPendingUpdates] = pendingUpdates;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
return createCallback(
(id: CanvasId, edgeId: string, opts?: OperationOptions) => {
@@ -677,7 +701,8 @@ export const useAddEdgeToGroup = sharedInstance(() => {
});
export const useCanvasGroups = sharedInstance(() => {
- const [pending, setPending] = pendingUpdates;
+ const [pending, setPending] =
+ useCanvasDocument().state.signals.pendingUpdates;
const saveCanvasData = useSaveCanvasData();
const getGroup = useGetGroup();
const rq = renderQueue();
@@ -717,12 +742,12 @@ export const useLoadCanvasData = sharedInstance(() => {
const nodes = useCanvasNodes();
const edges = useCanvasEdges();
const groups = useCanvasGroups();
- const setHighestOrder = highestOrderSignal.set;
+ const setHighestOrder = useCanvasDocument().state.signals.highestOrder[1];
const assertLayerAndSortOrder = (entity: CanvasEntity) => {
if (entity.layer === undefined) entity.layer = 0;
if (entity.sortOrder === undefined) entity.sortOrder = 0;
};
- return async (json: Canvas) => {
+ return async (json: Canvas, shouldApply: () => boolean = () => true) => {
let highestSortOrder = 0;
const nodeMap = await filterMapAsync<any, CanvasNode>(
@@ -742,6 +767,8 @@ export const useLoadCanvasData = sharedInstance(() => {
}
}
);
+ if (!shouldApply()) return false;
+
const edgeMap = await filterMapAsync<any, CanvasEdge>(
json.edges || [],
async (edge) => {
@@ -753,6 +780,8 @@ export const useLoadCanvasData = sharedInstance(() => {
}
}
);
+ if (!shouldApply()) return false;
+
const groupMap = await filterMapAsync<any, CanvasGroup>(
json.groups || [],
async (group) => {
@@ -764,18 +793,20 @@ export const useLoadCanvasData = sharedInstance(() => {
}
}
);
+ if (!shouldApply()) return false;
nodes.initialize(nodeMap, { initialize: true });
edges.initialize(edgeMap, { initialize: true });
groups.initialize(groupMap, { initialize: true });
setHighestOrder(highestSortOrder);
+ return true;
};
});
export const useExportCanvasData = sharedInstance(() => {
const getNode = useGetNode();
const getEdge = useGetEdge();
- const [canvasGroups] = groupStore;
+ const [canvasGroups] = useCanvasDocument().state.stores.groups;
const rq = renderQueue();
return (): Canvas => {
const nodes: CanvasNode[] = [];
@@ -807,29 +838,16 @@ export const useExportCanvasData = sharedInstance(() => {
// Immediate save function (not debounced)
export const useSaveCanvasDataImmediate = sharedInstance(() => {
const exportCanvasData = useExportCanvasData();
- const [, setPendingUpdates] = pendingUpdates;
- const setCurrentSavedFile = currentSavedFile.set;
+ const [, setPendingUpdates] =
+ useCanvasDocument().state.signals.pendingUpdates;
+ const setCurrentSavedFile =
+ useCanvasDocument().state.signals.currentSavedFile[1];
+ const documentId = useCanvasDocument().documentId();
return createCallback(async () => {
- const dssFile = blockDataSignal()?.dssFile;
- if (!dssFile) {
- console.error('no dss file');
- return;
- }
- const { documentId } = dssFile.getMetadata();
-
const canvas = exportCanvasData();
- const encoder = new TextEncoder();
- const buffer = encoder.encode(JSON.stringify(canvas));
-
- const file = new Blob([buffer], { type: 'application/x-macro-canvas' });
-
- const saveRes = await storageServiceClient.simpleSave({
- documentId,
- file,
- });
-
- if (saveRes.isErr()) {
+ const { file, saved } = await saveCanvasDocument(documentId, canvas);
+ if (!saved) {
console.error('error on canvas save');
}
@@ -839,7 +857,7 @@ export const useSaveCanvasDataImmediate = sharedInstance(() => {
});
});
-// save block-level canvas data to DSS (debounced)
+// Save document-level canvas data to DSS (debounced).
export const useSaveCanvasData = sharedInstance(() => {
const saveImmediate = useSaveCanvasDataImmediate();
return debounce(saveImmediate, 1500);
diff --git a/apps/web/src/features/block-canvas/store/getNodeEdge.ts b/apps/web/src/features/block-canvas/store/getNodeEdge.ts
index 60b7404aac..726331027e 100644
--- a/apps/web/src/features/block-canvas/store/getNodeEdge.ts
+++ b/apps/web/src/features/block-canvas/store/getNodeEdge.ts
@@ -1,19 +1,19 @@
import type { CanvasId } from '@block-canvas/model/CanvasModel';
import { sharedInstance } from '@block-canvas/util/sharedInstance';
import { createCallback } from '@solid-primitives/rootless';
-import { edgesStore, groupStore, nodesStore } from './nodesStore';
+import { useCanvasDocument } from '../context/canvas-document-context';
export const useGetEdge = sharedInstance(() => {
- const [store] = edgesStore;
+ const [store] = useCanvasDocument().state.stores.edges;
return createCallback((id: CanvasId) => store[id]);
});
export const useGetNode = sharedInstance(() => {
- const [store] = nodesStore;
+ const [store] = useCanvasDocument().state.stores.nodes;
return createCallback((id: CanvasId) => store[id]);
});
export const useGetGroup = sharedInstance(() => {
- const [store] = groupStore;
+ const [store] = useCanvasDocument().state.stores.groups;
return createCallback((id: CanvasId) => store[id]);
});
diff --git a/apps/web/src/features/block-canvas/store/nodesStore.ts b/apps/web/src/features/block-canvas/store/nodesStore.ts
deleted file mode 100644
index 3e389628dd..0000000000
--- a/apps/web/src/features/block-canvas/store/nodesStore.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-import type {
- CanvasEdge,
- CanvasGroup,
- CanvasId,
- CanvasNode,
-} from '@block-canvas/model/CanvasModel';
-import { createBlockStore } from '@core/block';
-
-/**
- * Reactive store for all node data on the canvas.
- */
-
-export const nodesStore = createBlockStore<Record<CanvasId, CanvasNode>>({});
-/**
- * Reactive store for all edge data on the canvas.
- */
-
-export const edgesStore = createBlockStore<Record<CanvasId, CanvasEdge>>({});
-/**
- * Reactive store for all group data on the canvas.
- */
-
-export const groupStore = createBlockStore<Record<CanvasId, CanvasGroup>>({});
diff --git a/apps/web/src/features/block-canvas/store/textNodeEditors.ts b/apps/web/src/features/block-canvas/store/textNodeEditors.ts
index 6eb9943806..cbab74062a 100644
--- a/apps/web/src/features/block-canvas/store/textNodeEditors.ts
+++ b/apps/web/src/features/block-canvas/store/textNodeEditors.ts
@@ -1,12 +1,9 @@
-import { createBlockStore } from '@core/block';
import type { LexicalEditor } from 'lexical';
-
-const textNodeEditorsStore = createBlockStore<Record<string, LexicalEditor>>(
- {}
-);
+import { useCanvasDocument } from '../context/canvas-document-context';
export function useTextNodeEditors() {
- const [textNodeEditors, setTextNodeEditors] = textNodeEditorsStore;
+ const [textNodeEditors, setTextNodeEditors] =
+ useCanvasDocument().state.stores.textNodeEditors;
return {
getEditor: (nodeId: string) => textNodeEditors[nodeId],
diff --git a/apps/web/src/features/block-canvas/util/renderQueue.ts b/apps/web/src/features/block-canvas/util/renderQueue.ts
index 61fd3cbe3d..7ddd268d47 100644
--- a/apps/web/src/features/block-canvas/util/renderQueue.ts
+++ b/apps/web/src/features/block-canvas/util/renderQueue.ts
@@ -1,6 +1,5 @@
-import { highestOrderSignal } from '@block-canvas/store/canvasData';
-import type { BlockStore } from '@core/block';
-import { createMemo, createSignal, untrack } from 'solid-js';
+import { createMemo, createSignal, type Setter, untrack } from 'solid-js';
+import type { SetStoreFunction, Store } from 'solid-js/store';
import {
type CanvasEdge,
type CanvasEntity,
@@ -100,16 +99,24 @@ function compare(a: Renderable, b: Renderable): number {
}
export function createRenderQueue(
- nodeStore: BlockStore<Record<CanvasId, CanvasNode>>,
- edgeStore: BlockStore<Record<CanvasId, CanvasEdge>>,
- groupStore: BlockStore<Record<CanvasId, CanvasGroup>>
+ nodeStore: [
+ Store<Record<CanvasId, CanvasNode>>,
+ SetStoreFunction<Record<CanvasId, CanvasNode>>,
+ ],
+ edgeStore: [
+ Store<Record<CanvasId, CanvasEdge>>,
+ SetStoreFunction<Record<CanvasId, CanvasEdge>>,
+ ],
+ groupStore: [
+ Store<Record<CanvasId, CanvasGroup>>,
+ SetStoreFunction<Record<CanvasId, CanvasGroup>>,
+ ],
+ setHighestOrder: Setter<number>
) {
const [nodes, setNodes] = nodeStore;
const [edges, setEdges] = edgeStore;
const [groups, setGroups] = groupStore;
const [list, setList] = createSignal<Renderable[]>([]);
- const setHighestOrder = highestOrderSignal.set;
-
const sorted = createMemo(() => {
const _list = list();
diff --git a/apps/web/src/features/block-canvas/util/sharedInstance.ts b/apps/web/src/features/block-canvas/util/sharedInstance.ts
index 17ddf7a41f..74fe248038 100644
--- a/apps/web/src/features/block-canvas/util/sharedInstance.ts
+++ b/apps/web/src/features/block-canvas/util/sharedInstance.ts
@@ -1,19 +1,23 @@
-import { createBlockSignal } from '@core/block';
-import type { Accessor } from 'solid-js';
+import { type Accessor, runWithOwner } from 'solid-js';
+import { useCanvasDocument } from '../context/canvas-document-context';
/**
- * Utility for creating some block-shared set of utilities that for
+ * Utility for creating a document-shared set of utilities that for
* performance or data-safety reasons should be enforced as a singleton
- * across a block. This is useful for building grouped, derived methods and
- * state on top of block resources.
+ * within one canvas. The document context owns each initialized instance.
*/
export function sharedInstance<T>(factory: () => T): Accessor<T> {
- let instance = createBlockSignal<T>();
+ const key = Symbol();
return () => {
- const [i, setI] = instance;
- if (i() === undefined) {
- setI(() => factory());
+ const canvas = useCanvasDocument();
+ const instances = canvas.state.instances;
+ if (!instances.has(key)) {
+ if (!canvas.instanceOwner) {
+ throw new Error('Canvas document instance owner is not initialized');
+ }
+ const instance = runWithOwner(canvas.instanceOwner, factory);
+ instances.set(key, instance);
}
- return i()!;
+ return instances.get(key) as T;
};
}
diff --git a/apps/web/src/lib/core/component/SlidableNumberInput.tsx b/apps/web/src/lib/core/component/SlidableNumberInput.tsx
index be5ae0247f..c325109310 100644
--- a/apps/web/src/lib/core/component/SlidableNumberInput.tsx
+++ b/apps/web/src/lib/core/component/SlidableNumberInput.tsx
@@ -1,4 +1,3 @@
-import { activeTextEditorSignal } from '@block-canvas/signal/toolManager';
import { clamp } from '@block-canvas/util/math';
import { type Vector2, vec2 } from '@block-canvas/util/vector2';
import CaretDown from '@phosphor/caret-down.svg';
@@ -30,6 +29,7 @@ type SlidableNumberInput = ComponentProps<'div'> & {
onSlideStart?: () => void;
onSlidePreview?: (newValue?: string) => void;
onSlideEnd?: (newValue?: string) => void;
+ onEditingChange?: (editing: boolean) => void;
currentValue: string;
presets: DropdownPreset[];
showPresets?: boolean;
@@ -52,7 +52,7 @@ const OptionalTooltipWrapper = (props: {
return <>{props.children}</>;
};
-type SlidableNumberInputProps = SlidableNumberInput;
+export type SlidableNumberInputProps = SlidableNumberInput;
export function SlidableNumberInput(props: SlidableNumberInputProps) {
const [dropdownOpen, setDropdownOpen] = createSignal<boolean>(false);
@@ -61,7 +61,6 @@ export function SlidableNumberInput(props: SlidableNumberInputProps) {
props.currentValue
);
const [mouseDownValue, setMouseDownValue] = createSignal<string>();
- const [, setActiveTextEditor] = activeTextEditorSignal;
function pointerMove(e: PointerEvent) {
if (!mouseDownPos()) return;
@@ -205,7 +204,7 @@ export function SlidableNumberInput(props: SlidableNumberInputProps) {
)}
contenteditable
onFocus={() => {
- setActiveTextEditor(true);
+ props.onEditingChange?.(true);
}}
onKeyDown={(e) => {
if (e.key === 'Enter') {
@@ -222,7 +221,7 @@ export function SlidableNumberInput(props: SlidableNumberInputProps) {
);
if (matchingPreset) props.inputChanged(matchingPreset.value);
} else props.inputChanged(e.currentTarget.innerText);
- setActiveTextEditor(false);
+ props.onEditingChange?.(false);
}}
>
{mouseDownValue() ?? currentValue()}