@ai-matrx/canvas 0.1.0 → 0.1.1

package/dist/react.d.ts

@@ -1,283 +1,6 @@
 import * as react from 'react';
 import { ComponentType, ReactNode, CSSProperties } from 'react';
-
-/**
- * @ai-matrx/canvas — core types.
- *
- * The canvas is ONE docked column on the right edge of an application. It holds
- * panes; panes hold tabs; every tab is one CanvasItem. A CanvasItem is
- * identified by `kind` + `key`, so opening the same thing twice always lands on
- * the existing tab instead of creating a duplicate.
- *
- * Everything in CanvasState is plain JSON: it lives in the host's Redux store
- * (or the package's own standalone store), it is persisted between sessions,
- * and it can be inspected. No functions, no class instances, no React nodes.
- */
-/** Any value that survives JSON.stringify → JSON.parse unchanged. */
-type CanvasJson = string | number | boolean | null | readonly CanvasJson[] | {
-    readonly [key: string]: CanvasJson | undefined;
-};
-declare const itemIdBrand: unique symbol;
-declare const paneIdBrand: unique symbol;
-declare const splitIdBrand: unique symbol;
-/** `${kind}::${key}` — the identity of one thing on the canvas. */
-type CanvasItemId = string & {
-    readonly [itemIdBrand]: true;
-};
-type CanvasPaneId = string & {
-    readonly [paneIdBrand]: true;
-};
-type CanvasSplitId = string & {
-    readonly [splitIdBrand]: true;
-};
-interface CanvasItem {
-    readonly id: CanvasItemId;
-    /** Registered kind id (see `registerCanvasKind`). */
-    readonly kind: string;
-    /** Stable key inside the kind — an artifact id, a conversation id, "default". */
-    readonly key: string;
-    /** Explicit tab title. `null` ⇒ the kind's `title(data)` or its label. */
-    readonly title: string | null;
-    readonly data: CanvasJson;
-    readonly openedAt: number;
-    readonly updatedAt: number;
-}
-interface CanvasPane {
-    readonly id: CanvasPaneId;
-    readonly itemIds: readonly CanvasItemId[];
-    readonly activeItemId: CanvasItemId | null;
-}
-/** "horizontal" = children side by side; "vertical" = children stacked. */
-type CanvasOrientation = "horizontal" | "vertical";
-type CanvasLayoutNode = {
-    readonly type: "pane";
-    readonly paneId: CanvasPaneId;
-} | {
-    readonly type: "split";
-    readonly id: CanvasSplitId;
-    readonly orientation: CanvasOrientation;
-    readonly children: readonly CanvasLayoutNode[];
-    /** Fractions, one per child, summing to 1. */
-    readonly sizes: readonly number[];
-};
-interface CanvasState {
-    readonly version: 1;
-    readonly isOpen: boolean;
-    readonly isFullscreen: boolean;
-    /** Column width in CSS pixels (desktop). */
-    readonly width: number;
-    readonly layout: CanvasLayoutNode;
-    readonly panes: {
-        readonly [paneId: string]: CanvasPane;
-    };
-    readonly items: {
-        readonly [itemId: string]: CanvasItem;
-    };
-    readonly focusedPaneId: CanvasPaneId;
-    /** Monotonic counter for minting pane/split ids — keeps the reducer pure. */
-    readonly seq: number;
-    /** True once a persisted snapshot was applied (or there was none). */
-    readonly hydrated: boolean;
-}
-/** Where a newly opened item goes. Existing items never move on open. */
-type CanvasOpenTarget = "focused" | "split-right" | "split-down" | {
-    readonly paneId: CanvasPaneId;
-};
-interface CanvasOpenInput {
-    readonly kind: string;
-    readonly key: string;
-    readonly title?: string | null | undefined;
-    readonly data?: CanvasJson | undefined;
-    readonly target?: CanvasOpenTarget | undefined;
-    /** Reveal the canvas when it is put away. Default true. */
-    readonly reveal?: boolean | undefined;
-    /** Make the item the pane's active tab. Default true. */
-    readonly activate?: boolean | undefined;
-}
-
-/**
- * THE canvas reducer. Plain Redux-compatible reducer + action creators with no
- * Redux Toolkit dependency, so it mounts in a host's RTK store
- * (`canvasHost: canvasReducer`) or runs inside the package's own standalone
- * store with identical behaviour.
- *
- * Identity law: an item is `kind::key`. Opening an item that is already on the
- * canvas never duplicates it — it refreshes its data/title, activates its tab
- * and focuses its pane, wherever that pane is.
- */
-
-declare const P = "matrxCanvas/";
-type CanvasAction = {
-    type: `${typeof P}open`;
-    payload: CanvasOpenInput & {
-        now: number;
-    };
-} | {
-    type: `${typeof P}update`;
-    payload: {
-        itemId: CanvasItemId;
-        data?: CanvasJson | undefined;
-        title?: string | null | undefined;
-        now: number;
-    };
-} | {
-    type: `${typeof P}rekey`;
-    payload: {
-        itemId: CanvasItemId;
-        key: string;
-    };
-} | {
-    type: `${typeof P}closeItem`;
-    payload: {
-        itemId: CanvasItemId;
-    };
-} | {
-    type: `${typeof P}closeOthers`;
-    payload: {
-        itemId: CanvasItemId;
-    };
-} | {
-    type: `${typeof P}activate`;
-    payload: {
-        itemId: CanvasItemId;
-    };
-} | {
-    type: `${typeof P}focusPane`;
-    payload: {
-        paneId: CanvasPaneId;
-    };
-} | {
-    type: `${typeof P}moveItem`;
-    payload: {
-        itemId: CanvasItemId;
-        toPaneId: CanvasPaneId;
-        index?: number | undefined;
-    };
-} | {
-    type: `${typeof P}splitPane`;
-    payload: {
-        paneId: CanvasPaneId;
-        orientation: CanvasOrientation;
-        moveItemId?: CanvasItemId | undefined;
-    };
-} | {
-    type: `${typeof P}closePane`;
-    payload: {
-        paneId: CanvasPaneId;
-    };
-} | {
-    type: `${typeof P}resizeSplit`;
-    payload: {
-        splitId: CanvasSplitId;
-        sizes: readonly number[];
-    };
-} | {
-    type: `${typeof P}setOpen`;
-    payload: {
-        open: boolean;
-    };
-} | {
-    type: `${typeof P}toggle`;
-} | {
-    type: `${typeof P}setFullscreen`;
-    payload: {
-        fullscreen: boolean;
-    };
-} | {
-    type: `${typeof P}setWidth`;
-    payload: {
-        width: number;
-    };
-} | {
-    type: `${typeof P}hydrate`;
-    payload: {
-        snapshot: CanvasState | null;
-    };
-} | {
-    type: `${typeof P}reset`;
-};
-
-/**
- * The store seam. The canvas never owns a second copy of its state: it reads
- * and writes through a CanvasStoreBinding.
- *
- *  - A host WITH Redux mounts `canvasReducer` in its root reducer and binds it:
- *      bindCanvasToReduxStore(store, (root) => root.canvasHost)
- *  - A host WITHOUT Redux (a Vite tool, an Electron window) calls
- *      createCanvasStore()
- *    which runs the very same reducer in a tiny standalone store.
- */
-
-interface CanvasStoreBinding {
-    getState(): CanvasState;
-    dispatch(action: CanvasAction): void;
-    subscribe(listener: () => void): () => void;
-}
-
-/**
- * Remembering the canvas between sessions — a table stake, never optional.
- *
- * The default port writes to localStorage under a versioned key. Items whose
- * kind opts out (`restore: false`, e.g. a live session that cannot come back)
- * are dropped from the snapshot, and panes they leave empty are dropped too.
- */
-
-interface CanvasPersistencePort {
-    load(): CanvasState | null | Promise<CanvasState | null>;
-    save(snapshot: CanvasState): void | Promise<void>;
-}
-
-/**
- * The canvas controller: the ONE imperative API every caller uses. It wraps a
- * store binding, validates what callers hand it (so the reducer stays pure and
- * trusting), and owns hydration + autosave.
- *
- * Nothing fails silently: a refused open (non-JSON data, unknown kind) is
- * reported through the error sink and returns false.
- */
-
-interface CanvasErrorReport {
-    readonly code: "non-json-data" | "unknown-kind" | "persistence-load" | "persistence-save";
-    readonly message: string;
-    readonly detail?: unknown;
-}
-type CanvasErrorSink = (report: CanvasErrorReport) => void;
-interface CanvasController {
-    readonly store: CanvasStoreBinding;
-    getState(): CanvasState;
-    open(input: CanvasOpenInput): CanvasItemId | null;
-    update(itemId: CanvasItemId, patch: {
-        data?: CanvasJson | undefined;
-        title?: string | null | undefined;
-    }): boolean;
-    /** Gives an item a new identity in place (a draft that was saved and now has a durable id). */
-    rekey(itemId: CanvasItemId, key: string): CanvasItemId | null;
-    close(itemId: CanvasItemId): void;
-    closeOthers(itemId: CanvasItemId): void;
-    activate(itemId: CanvasItemId): void;
-    focusPane(paneId: CanvasPaneId): void;
-    moveItem(itemId: CanvasItemId, toPaneId: CanvasPaneId, index?: number): void;
-    splitPane(paneId: CanvasPaneId, orientation: CanvasOrientation, moveItemId?: CanvasItemId): void;
-    closePane(paneId: CanvasPaneId): void;
-    resizeSplit(splitId: CanvasSplitId, sizes: readonly number[]): void;
-    show(): void;
-    hide(): void;
-    toggle(): void;
-    setFullscreen(fullscreen: boolean): void;
-    setWidth(width: number): void;
-    /** Is this exact thing on the canvas right now? */
-    has(kind: string, key: string): boolean;
-    /**
-     * Is a canvas column on screen? A store can exist in a layout that shows no
-     * column (a kiosk, a meeting stage); opening there must be refused aloud.
-     */
-    isPresented(): boolean;
-    /** Called by a column on mount; returns the unmount callback. */
-    registerPresentation(): () => void;
-    subscribePresentation(listener: () => void): () => void;
-    /** Loads the persisted snapshot and starts autosave. Returns a disposer. */
-    start(): () => void;
-}
+import { a as CanvasJson, e as CanvasItem, c as CanvasPaneId, l as CanvasController, u as CanvasStoreBinding, s as CanvasPersistencePort, o as CanvasErrorSink, d as CanvasState } from './controller-oY84BN2c.js';
 
 /**
  * THE canvas kind registry. A kind is one sort of thing the canvas can show —

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-matrx/canvas",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "The AI Matrx canvas: a docked right-hand column with split panes, tabs, full screen, a kind registry, Redux-compatible state and persistence.",
   "type": "module",
   "main": "./dist/index.cjs",