@draftably/editor 0.0.0-stage → 0.2.0

package/dist/types/src/state/session/scene.d.ts

@@ -0,0 +1,144 @@
+import type { PriorRoute, RoutingResult } from '../../engines/routing-engine.js';
+import { type VisibleGraph } from '../../model/graph';
+import { type DrawnRoute } from '../../model/routes';
+import type { NodeGeometry, NodeLayout, Rect } from '../../model/types';
+import type { DocumentPart } from './document';
+import type { FileSessionPart } from './file-session';
+export declare function createScene(s: DocumentPart & FileSessionPart): {
+    sculptGeometry: import("solid-js").Accessor<NodeGeometry | null>;
+    setSculptGeometry: import("solid-js").Setter<NodeGeometry | null>;
+    animationGeometry: import("solid-js").Accessor<NodeGeometry | null>;
+    setAnimationGeometry: import("solid-js").Setter<NodeGeometry | null>;
+    setQuickRouting: import("solid-js").Setter<boolean>;
+    routePrior: import("solid-js").Accessor<PriorRoute[] | null>;
+    setRoutePrior: import("solid-js").Setter<PriorRoute[] | null>;
+    setAdoptedRoutes: import("solid-js").Setter<{
+        fingerprint: string;
+        result: RoutingResult;
+    } | null>;
+    geometry: (id: string) => NodeLayout;
+    visibleScene: import("solid-js").Accessor<VisibleGraph>;
+    nodeIds: import("solid-js").Accessor<string[]>;
+    groupIds: import("solid-js").Accessor<string[]>;
+    edgeIds: import("solid-js").Accessor<string[]>;
+    sceneRects: import("solid-js").Accessor<Map<string, Rect>>;
+    routing: import("solid-js").Accessor<import("../../model/routes").SceneRoutes>;
+    routesById: import("solid-js").Accessor<Map<string, DrawnRoute>>;
+    routeIds: import("solid-js").Accessor<string[]>;
+    routesPending: () => boolean;
+    resetRoutes: () => void;
+    routeInputFor: () => {
+        nodes: ({
+            shape: import("../../model/types").ShapeKind;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            id: string;
+            title: string;
+            was?: string;
+            wasShape?: import("../../model/types").ShapeKind;
+            wasCount?: number | string;
+            href?: string;
+            count?: number | string;
+            span?: number | "var";
+            parentId?: string;
+            image?: string;
+            lifeline?: number;
+        } | {
+            parentId?: string | undefined;
+            frame?: boolean | undefined;
+            shape: import("../../model/types").ShapeKind;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            id: string;
+            title: string;
+        })[];
+        groups: {
+            titleHeight?: number | undefined;
+            collapsed: boolean;
+            titleWidth: number;
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+            id: string;
+            title: string;
+            was?: string;
+            href?: string;
+            parentId?: string;
+            frame?: "soft" | "none";
+            titleLines?: number;
+            hull?: Rect[];
+        }[];
+        edges: {
+            from: string;
+            to: string;
+            cfg: import("../../model/types").EdgeLayout;
+            a: string;
+            b: string;
+            id: string;
+            label: string;
+            was?: string;
+            directed: boolean;
+            head?: import("../../model/markers.js").EndMarker;
+            tail?: import("../../model/markers.js").EndMarker;
+            emphasis: boolean;
+            dashed: boolean;
+            status?: import("../../model/status").Status;
+            spot?: import("../../model/status").Spot;
+        }[];
+    };
+    routes: () => DrawnRoute[];
+    routingReport: () => import("../../engines/routing-engine.js").RoutingReport;
+    blockedRouteIds: () => string[];
+    sceneBounds: () => Rect;
+    viewerFrame: () => {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+        natural: number;
+        head: {
+            w: number;
+            h: number;
+        };
+        key: {
+            w: number;
+            h: number;
+            row: number;
+            items: {
+                x: number;
+                y: number;
+                legend?: import("../../model/appearance").LegendEntry;
+                status?: import("../../model/status").StatusCount;
+                label: string;
+            }[];
+        };
+        heading: {
+            x: number;
+            y: number;
+            wrap: number;
+        };
+        legend: {
+            x: number;
+            y: number;
+        };
+        foot: {
+            x: number;
+            y: number;
+            type: import("../../model/fonts.js").TypeProfile;
+            gutter: number;
+            items: {
+                note: import("../../model/footnote.js").Footnote;
+                lines: import("../../model/rich-text.js").Run[][];
+                y: number;
+            }[];
+            h: number;
+        };
+        notes: import("../../model/note").PlacedNote[];
+    };
+};
+export type ScenePart = ReturnType<typeof createScene>;

package/dist/types/src/state/session/sculpt.d.ts

@@ -0,0 +1,70 @@
+import { type BrushSettings, type DabResult, type Timeline } from '../../engines/sculpt-engine.js';
+import type { Point } from '../../model/types';
+import type { DocumentPart } from './document';
+import type { LayoutPart } from './layout';
+import type { ActionsPart } from './actions';
+import type { EditorPart } from './editor';
+import type { ScenePart } from './scene';
+export type GhostMode = 'next' | 'final' | 'off';
+export interface TimelineState {
+    signature: string;
+    scope: string;
+    algorithm: string;
+    busy: boolean;
+    index: number;
+    peek: number | null;
+    ghost: GhostMode;
+    data: Timeline | null;
+}
+export declare function validateTimeline(input: unknown): Timeline;
+export declare function createSculpt(s: DocumentPart & LayoutPart & ActionsPart & EditorPart & ScenePart): {
+    importTimeline: (input: unknown) => void;
+    timeline: import("solid-js").Accessor<TimelineState | null>;
+    playing: import("solid-js").Accessor<boolean>;
+    brushActive: import("solid-js").Accessor<boolean>;
+    brushSettings: import("solid-js").Accessor<BrushSettings>;
+    brushPoint: import("solid-js").Accessor<Point | null>;
+    brushHover: import("solid-js").Accessor<DabResult | null>;
+    stroking: import("solid-js").Accessor<boolean>;
+    restoreKey: import("solid-js").Accessor<boolean>;
+    referenceLabel: import("solid-js").Accessor<string>;
+    timelineOpen: () => boolean;
+    sculptInteracting: () => boolean;
+    heldIds: () => string[];
+    restoreArchive: () => void;
+    openTimeline: (options?: Record<string, unknown>) => Promise<void>;
+    closeTimeline: () => void;
+    scrub: (index: number, { peek }?: {
+        peek?: boolean | undefined;
+    }) => number | undefined;
+    endPeek: () => void;
+    setGhost: (ghost: GhostMode) => void;
+    bookmarkStep: () => void;
+    keepStep: ({ brush }?: {
+        brush?: boolean | undefined;
+    }) => boolean;
+    stopPlayback: () => void;
+    togglePlayback: () => void;
+    fitTimelinePath: (reservedBottom: number) => void;
+    reopenTimeline: () => void;
+    saveTimelineFile: () => void;
+    activateBrush: (options?: Partial<BrushSettings>) => void;
+    deactivateBrush: () => void;
+    toggleBrush: () => void;
+    updateBrushSettings: (patch: Partial<BrushSettings>) => void;
+    useCurrentAsReference: () => void;
+    brushPointerDown: (e: PointerEvent, target: Element) => boolean;
+    brushPointerMove: (e: PointerEvent) => boolean;
+    brushPointerUp: (e?: PointerEvent) => boolean;
+    brushPointerLeave: () => void;
+    cancelStroke: () => boolean;
+    brushDab: (point?: Point) => DabResult;
+    clearHolds: () => void;
+    sculptUndo: () => boolean;
+    sculptKey: (e: KeyboardEvent) => boolean;
+    sculptBlur: () => void;
+    sculptBeforeUnload: () => void;
+    hasArchivedTimeline: import("solid-js").Accessor<boolean>;
+    setComparisonCloser: (fn: () => void) => () => void;
+};
+export type SculptPart = ReturnType<typeof createSculpt>;

package/dist/types/src/state/toast.d.ts

@@ -0,0 +1,14 @@
+/** A button on a toast, such as a way to take back what the message reports. */
+export interface ToastAction {
+    label: string;
+    run: () => void;
+}
+export declare const toastMessage: import("solid-js").Accessor<{
+    text: string;
+    id: number;
+    action?: ToastAction;
+} | null>;
+/** Show a short status message at the bottom of the screen, with an optional button. */
+export declare function toast(text: string, action?: ToastAction): void;
+/** Hide the toast now. */
+export declare function dismissToast(): void;

package/dist/types/src/state/workspace.d.ts

@@ -0,0 +1,3 @@
+import type { WorkspaceInfo } from '../server/workspace';
+/** The served folder, or null on the static site and in an embedded editor. */
+export declare const workspace: import("solid-js").Accessor<WorkspaceInfo | null>, setWorkspace: import("solid-js").Setter<WorkspaceInfo | null>;

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@draftably/editor",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "description": "The Draftably diagram editor: drag boxes and lines, and get the .draft source back.",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/src/editor/mount.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./element": {
+      "types": "./dist/types/src/editor/element.d.ts",
+      "import": "./dist/element.js",
+      "default": "./dist/element.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": [
+    "./dist/element.js",
+    "./dist/index.js",
+    "./dist/chunks/*.js"
+  ],
+  "engines": {
+    "node": ">=22.21.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/byronwall/draftably.git",
+    "directory": "packages/editor"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-editor.ts"
+  }
 }