@next-buildr/editor 0.0.0-stage → 2.0.0

package/dist/dnd/geometry.js

@@ -0,0 +1,31 @@
+export const rectContains = (rect, point) => point.x >= rect.left &&
+    point.x < rect.left + rect.width &&
+    point.y >= rect.top &&
+    point.y < rect.top + rect.height;
+/**
+ * A pointer position in the window (`clientX/Y`) as the canvas sees it: relative to the frame's
+ * top-left corner and divided by the zoom the frame is shown at (`scale` 0.5 means the page is drawn
+ * at half size). A frame that is not laid out (zero scale) gives `undefined` rather than infinity.
+ */
+export function toCanvasPoint(client, frame, scale = 1) {
+    if (!(scale > 0) || !Number.isFinite(scale))
+        return undefined;
+    return { x: (client.x - frame.left) / scale, y: (client.y - frame.top) / scale };
+}
+/**
+ * How far to scroll a region this frame while a drag is near its top or bottom edge: 0 in the
+ * middle, growing linearly to `maxSpeed` at the edge (and past it, so a pointer that left the
+ * region keeps scrolling), negative upwards.
+ */
+export function autoscrollDelta(region, pointerY, { edge = 48, maxSpeed = 24 } = {}) {
+    const fromTop = pointerY - region.top;
+    const fromBottom = region.top + region.height - pointerY;
+    const zone = Math.min(edge, region.height / 2);
+    if (zone <= 0)
+        return 0;
+    if (fromTop < zone)
+        return -maxSpeed * Math.min(1, (zone - fromTop) / zone);
+    if (fromBottom < zone)
+        return maxSpeed * Math.min(1, (zone - fromBottom) / zone);
+    return 0;
+}

package/dist/dnd/index.d.ts

@@ -0,0 +1,14 @@
+export type { Destination } from './destinations.ts';
+export { moveDestinations } from './destinations.ts';
+export type { CanvasSurface, DragEngine, DragEngineOptions, DragHost, DragOver, DragPhase, DragState, DragSurfaces, TreeSurface, } from './engine.ts';
+export { createDragEngine, DRAG_THRESHOLD } from './engine.ts';
+export { fragmentFor } from './fragment.ts';
+export type { AutoscrollOptions, Point, Rect } from './geometry.ts';
+export { autoscrollDelta, rectContains, toCanvasPoint } from './geometry.ts';
+export type { MoveToDialogProps } from './move-to-dialog.tsx';
+export { MoveToDialog } from './move-to-dialog.tsx';
+export type { DragProviderProps } from './react.tsx';
+export { DragProvider, useDragAutoscroll, useDragAvailable, useDragEngine, useDragPress, useDragSource, useDragState, useRegisterCanvas, useRegisterDragHost, useRegisterTree, } from './react.tsx';
+export type { TreeDropInput, TreeDropResult, TreePosition } from './tree-target.ts';
+export { treeDropTarget } from './tree-target.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/dnd/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/dnd/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,YAAY,EACV,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,SAAS,EACT,YAAY,EACZ,WAAW,GACZ,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,iBAAiB,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC7E,YAAY,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EACL,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,iBAAiB,EACjB,mBAAmB,EACnB,eAAe,GAChB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACpF,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/dnd/index.js

@@ -0,0 +1,7 @@
+export { moveDestinations } from './destinations.js';
+export { createDragEngine, DRAG_THRESHOLD } from './engine.js';
+export { fragmentFor } from './fragment.js';
+export { autoscrollDelta, rectContains, toCanvasPoint } from './geometry.js';
+export { MoveToDialog } from './move-to-dialog.js';
+export { DragProvider, useDragAutoscroll, useDragAvailable, useDragEngine, useDragPress, useDragSource, useDragState, useRegisterCanvas, useRegisterDragHost, useRegisterTree, } from './react.js';
+export { treeDropTarget } from './tree-target.js';

package/dist/dnd/move-to-dialog.d.ts

@@ -0,0 +1,13 @@
+import type { NodeId } from '@next-buildr/core';
+export interface MoveToDialogProps {
+    readonly open: boolean;
+    readonly onOpenChange: (open: boolean) => void;
+    /** The nodes to move. */
+    readonly ids: readonly NodeId[];
+}
+/**
+ * "Move to": the keyboard way to do what dragging does. It lists the places the rules allow (the
+ * end of a slot of any node) and moves the nodes there with the same drop the pointer uses.
+ */
+export declare function MoveToDialog({ open, onOpenChange, ids }: MoveToDialogProps): import("react").JSX.Element;
+//# sourceMappingURL=move-to-dialog.d.ts.map

package/dist/dnd/move-to-dialog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-to-dialog.d.ts","sourceRoot":"","sources":["../../src/dnd/move-to-dialog.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAQhD,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IAC/C,yBAAyB;IACzB,QAAQ,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,EAAE,iBAAiB,+BA2C1E"}

package/dist/dnd/move-to-dialog.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { useT } from '../messages/index.js';
+import { useEditor } from '../store/index.js';
+import { Button, Dialog } from '../ui/index.js';
+import { moveDestinations } from './destinations.js';
+import { useDragEngine } from './react.js';
+/**
+ * "Move to": the keyboard way to do what dragging does. It lists the places the rules allow (the
+ * end of a slot of any node) and moves the nodes there with the same drop the pointer uses.
+ */
+export function MoveToDialog({ open, onOpenChange, ids }) {
+    const t = useT();
+    const store = useEditor();
+    const engine = useDragEngine();
+    const destinations = useMemo(() => {
+        if (!open)
+            return [];
+        return moveDestinations(store.getState().doc, store.registry, ids);
+    }, [open, store, ids]);
+    const label = (id) => {
+        const node = store.getState().doc.nodes[id];
+        return node?.name ?? store.registry.get(node?.type ?? '')?.label ?? node?.type ?? id;
+    };
+    return (_jsx(Dialog, { open: open, onOpenChange: onOpenChange, title: t('dnd.moveTo.title'), description: t('dnd.moveTo.description'), children: destinations.length === 0 ? (_jsx("p", { className: "bd-dnd-empty", children: t('dnd.moveTo.none') })) : (_jsx("ul", { className: "bd-dnd-destinations", children: destinations.map((destination) => (_jsx("li", { children: _jsxs(Button, { variant: "ghost", onClick: () => {
+                        const result = engine.drop({ kind: 'nodes', ids }, destination.target);
+                        if (result.ok)
+                            onOpenChange(false);
+                    }, children: [t('dnd.moveTo.into'), " ", label(destination.parentId), destination.slot === 'default' ? '' : ` › ${destination.slot}`] }) }, `${destination.parentId}/${destination.slot}`))) })) }));
+}

package/dist/dnd/react.d.ts

@@ -0,0 +1,43 @@
+import type { DragItem } from '@next-buildr/core';
+import { type ReactNode, type PointerEvent as ReactPointerEvent, type RefObject } from 'react';
+import { type CanvasSurface, type DragEngine, type DragHost, type DragState, type TreeSurface } from './engine.ts';
+/** The engine, for what wires it (`receiveTarget` from the canvas' `dnd:target`, "Move to…"). */
+export declare function useDragEngine(): DragEngine;
+/** The drag as it stands, for indicators; only what `select` returns causes a render. */
+export declare function useDragState<T>(select: (state: DragState) => T): T;
+/** The canvas hands over where its frame is (window coordinates) and how far it is zoomed. */
+export declare function useRegisterCanvas(surface: () => CanvasSurface | undefined): void;
+/** The layers tree hands over its viewport, scroll position and rows. */
+export declare function useRegisterTree(surface: () => TreeSurface | undefined): void;
+/** The canvas host the drag forwards to; `null` while there is none. */
+export declare function useRegisterDragHost(host: DragHost | null): void;
+export interface DragProviderProps {
+    readonly children: ReactNode;
+}
+/**
+ * Owns the engine of an editor, listens to the pointer and Escape while something is dragged, puts
+ * a shield over the page (the canvas iframe would otherwise swallow the pointer events), and draws
+ * the ghost that follows the pointer. What it says for the screen reader is a live region.
+ */
+export declare function DragProvider({ children }: DragProviderProps): import("react").JSX.Element;
+export interface DragSourceProps {
+    readonly onPointerDown: (event: ReactPointerEvent<HTMLElement>) => void;
+}
+/**
+ * Props that make an element start a drag on primary-button press. `item` may be a function, so a
+ * tree row can decide at press time (the whole selection or just this row).
+ */
+export declare function useDragSource(item: DragItem | (() => DragItem), label: string | (() => string)): (event: ReactPointerEvent<HTMLElement>) => void;
+/** Whether a `DragProvider` is above: panels offer dragging and "Move to" only then. */
+export declare function useDragAvailable(): boolean;
+/**
+ * Starts a drag from a pointer event of something that decides at press time what is dragged (a row
+ * of the layers tree); `undefined` without a provider.
+ */
+export declare function useDragPress(): ((item: DragItem, label: string, event: ReactPointerEvent<HTMLElement>) => void) | undefined;
+/**
+ * While something is dragged over `element`, scrolls it when the pointer is near its top or bottom
+ * edge, once per animation frame, and re-hovers so the target follows what scrolled under the pointer.
+ */
+export declare function useDragAutoscroll(element: RefObject<HTMLElement | null>): void;
+//# sourceMappingURL=react.d.ts.map

package/dist/dnd/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/dnd/react.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,YAAY,IAAI,iBAAiB,EACtC,KAAK,SAAS,EAOf,MAAM,OAAO,CAAC;AAIf,OAAO,EACL,KAAK,aAAa,EAElB,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,SAAS,EAEd,KAAK,WAAW,EACjB,MAAM,aAAa,CAAC;AA6BrB,iGAAiG;AACjG,wBAAgB,aAAa,IAAI,UAAU,CAE1C;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,CAAC,GAAG,CAAC,CAOlE;AAED,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,aAAa,GAAG,SAAS,GAAG,IAAI,CAUhF;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,WAAW,GAAG,SAAS,GAAG,IAAI,CAW5E;AAED,wEAAwE;AACxE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,IAAI,CAQ/D;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAAE,QAAQ,EAAE,EAAE,iBAAiB,+BAiD3D;AA8BD,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,iBAAiB,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC;CACzE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,QAAQ,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,WAKnF,iBAAiB,CAAC,WAAW,CAAC,UASzC;AAED,wFAAwF;AACxF,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAED;;;GAGG;AACH,wBAAgB,YAAY,IACxB,CAAC,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,CAAC,WAAW,CAAC,KAAK,IAAI,CAAC,GAChF,SAAS,CAYZ;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,IAAI,CA0B9E"}

package/dist/dnd/react.js

@@ -0,0 +1,185 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useSyncExternalStore, } from 'react';
+import { useStore } from 'zustand';
+import { useT } from '../messages/index.js';
+import { useEditor } from '../store/index.js';
+import { createDragEngine, IDLE_STATE, } from './engine.js';
+import { autoscrollDelta } from './geometry.js';
+const IDLE_STORE = { getState: () => IDLE_STATE };
+const DragContext = createContext(null);
+function useDragContext() {
+    const value = useContext(DragContext);
+    if (value === null)
+        throw new Error('DragProvider is missing');
+    return value;
+}
+/** Panels work without a provider (no dragging, no indicators): tests and embeds that do not need it. */
+const useOptionalDrag = () => useContext(DragContext);
+const noSubscription = () => () => undefined;
+/** The engine, for what wires it (`receiveTarget` from the canvas' `dnd:target`, "Move to…"). */
+export function useDragEngine() {
+    return useDragContext().engine;
+}
+/** The drag as it stands, for indicators; only what `select` returns causes a render. */
+export function useDragState(select) {
+    const drag = useOptionalDrag();
+    return useSyncExternalStore(drag === null ? noSubscription : drag.engine.state.subscribe, () => select((drag?.engine.state ?? IDLE_STORE).getState()), () => select(IDLE_STATE));
+}
+/** The canvas hands over where its frame is (window coordinates) and how far it is zoomed. */
+export function useRegisterCanvas(surface) {
+    const { registry } = useDragContext();
+    const ref = useRef(surface);
+    ref.current = surface;
+    useEffect(() => {
+        registry.canvas = () => ref.current();
+        return () => {
+            registry.canvas = null;
+        };
+    }, [registry]);
+}
+/** The layers tree hands over its viewport, scroll position and rows. */
+export function useRegisterTree(surface) {
+    const registry = useOptionalDrag()?.registry;
+    const ref = useRef(surface);
+    ref.current = surface;
+    useEffect(() => {
+        if (registry === undefined)
+            return;
+        registry.tree = () => ref.current();
+        return () => {
+            registry.tree = null;
+        };
+    }, [registry]);
+}
+/** The canvas host the drag forwards to; `null` while there is none. */
+export function useRegisterDragHost(host) {
+    const { registry } = useDragContext();
+    useEffect(() => {
+        registry.host = host;
+        return () => {
+            registry.host = null;
+        };
+    }, [registry, host]);
+}
+/**
+ * Owns the engine of an editor, listens to the pointer and Escape while something is dragged, puts
+ * a shield over the page (the canvas iframe would otherwise swallow the pointer events), and draws
+ * the ghost that follows the pointer. What it says for the screen reader is a live region.
+ */
+export function DragProvider({ children }) {
+    const store = useEditor();
+    const value = useMemo(() => {
+        const registry = { canvas: null, tree: null, host: null };
+        const engine = createDragEngine({
+            store,
+            host: () => registry.host ?? undefined,
+            surfaces: { canvas: () => registry.canvas?.(), tree: () => registry.tree?.() },
+        });
+        return { engine, registry };
+    }, [store]);
+    const { engine } = value;
+    const phase = useStore(engine.state, (s) => s.phase);
+    useEffect(() => {
+        if (phase === 'idle')
+            return;
+        const move = (event) => engine.move({ x: event.clientX, y: event.clientY });
+        const up = () => {
+            engine.release();
+        };
+        const cancel = () => engine.cancel();
+        const key = (event) => {
+            if (event.key !== 'Escape')
+                return;
+            event.preventDefault();
+            event.stopPropagation();
+            engine.cancel();
+        };
+        window.addEventListener('pointermove', move);
+        window.addEventListener('pointerup', up);
+        window.addEventListener('pointercancel', cancel);
+        window.addEventListener('blur', cancel);
+        window.addEventListener('keydown', key, true);
+        return () => {
+            window.removeEventListener('pointermove', move);
+            window.removeEventListener('pointerup', up);
+            window.removeEventListener('pointercancel', cancel);
+            window.removeEventListener('blur', cancel);
+            window.removeEventListener('keydown', key, true);
+        };
+    }, [engine, phase]);
+    useEffect(() => () => engine.dispose(), [engine]);
+    return (_jsxs(DragContext.Provider, { value: value, children: [children, _jsx(DragOverlay, { engine: engine })] }));
+}
+function DragOverlay({ engine }) {
+    const t = useT();
+    const state = useStore(engine.state);
+    const dragging = state.phase === 'dragging';
+    return (_jsxs(_Fragment, { children: [dragging ? (_jsx("div", { className: "bd-drag-shield", "data-over": state.over ?? 'none', "aria-hidden": "true" })) : null, dragging && state.pointer !== null ? (_jsx("div", { className: "bd-drag-ghost", "aria-hidden": "true", "data-allowed": state.target !== null, style: { transform: `translate(${state.pointer.x + 12}px, ${state.pointer.y + 12}px)` }, children: state.label })) : null, _jsx("div", { className: "bd-drag-live", role: "status", "aria-live": "polite", children: dragging && state.over !== null && state.target === null
+                    ? `${t('dnd.notAllowed')} ${state.reason?.message ?? ''}`.trim()
+                    : '' })] }));
+}
+/**
+ * Props that make an element start a drag on primary-button press. `item` may be a function, so a
+ * tree row can decide at press time (the whole selection or just this row).
+ */
+export function useDragSource(item, label) {
+    const engine = useOptionalDrag()?.engine;
+    const latest = useRef({ item, label });
+    latest.current = { item, label };
+    return useCallback((event) => {
+        if (engine === undefined || event.button !== 0 || !event.isPrimary)
+            return;
+        const current = latest.current;
+        const resolved = typeof current.item === 'function' ? current.item() : current.item;
+        const text = typeof current.label === 'function' ? current.label() : current.label;
+        engine.press(resolved, text, { x: event.clientX, y: event.clientY });
+    }, [engine]);
+}
+/** Whether a `DragProvider` is above: panels offer dragging and "Move to" only then. */
+export function useDragAvailable() {
+    return useOptionalDrag() !== null;
+}
+/**
+ * Starts a drag from a pointer event of something that decides at press time what is dragged (a row
+ * of the layers tree); `undefined` without a provider.
+ */
+export function useDragPress() {
+    const engine = useOptionalDrag()?.engine;
+    return useMemo(() => engine === undefined
+        ? undefined
+        : (item, label, event) => {
+            if (event.button !== 0 || !event.isPrimary)
+                return;
+            engine.press(item, label, { x: event.clientX, y: event.clientY });
+        }, [engine]);
+}
+/**
+ * While something is dragged over `element`, scrolls it when the pointer is near its top or bottom
+ * edge, once per animation frame, and re-hovers so the target follows what scrolled under the pointer.
+ */
+export function useDragAutoscroll(element) {
+    const engine = useOptionalDrag()?.engine;
+    const active = useDragState((state) => state.phase === 'dragging' && state.over === 'tree');
+    useEffect(() => {
+        if (engine === undefined || !active)
+            return;
+        let handle = 0;
+        const tick = () => {
+            const target = element.current;
+            const pointer = engine.state.getState().pointer;
+            if (target !== null && pointer !== null) {
+                const box = target.getBoundingClientRect();
+                const delta = autoscrollDelta({ left: box.left, top: box.top, width: box.width, height: box.height }, pointer.y);
+                if (delta !== 0) {
+                    const before = target.scrollTop;
+                    target.scrollTop = before + delta;
+                    if (target.scrollTop !== before)
+                        engine.move(pointer);
+                }
+            }
+            handle = requestAnimationFrame(tick);
+        };
+        handle = requestAnimationFrame(tick);
+        return () => cancelAnimationFrame(handle);
+    }, [engine, active, element]);
+}

package/dist/dnd/tree-target.d.ts

@@ -0,0 +1,29 @@
+import { type BuilderDocument, type DragItem, type DropTarget, type Reason, type RegistryMeta } from '@next-buildr/core';
+import type { LayerRow } from '../panels/layers/flatten.ts';
+export type TreePosition = 'before' | 'inside' | 'after';
+export interface TreeDropResult {
+    readonly target: DropTarget | null;
+    /** The row the indicator is drawn at and on which side of it (or over it, for "inside"). */
+    readonly rowIndex: number;
+    readonly position: TreePosition;
+    /** Why nothing accepts the drop, from the rule that refused the spot nearest the pointer. */
+    readonly reason?: Reason | undefined;
+}
+export interface TreeDropInput {
+    readonly doc: BuilderDocument;
+    readonly registry: RegistryMeta;
+    readonly rows: readonly LayerRow[];
+    readonly item: DragItem;
+    /** The pointer's distance from the top of the list's content (scroll included). */
+    readonly y: number;
+    readonly rowHeight: number;
+}
+/**
+ * Where a drop over the layers tree would land: the row under the pointer picks the spot (its top
+ * quarter is before it, its bottom quarter after it, the middle inside it) and the rules
+ * (`canInsert`/`canMove`) accept or refuse it. When they refuse, the nearest legal alternatives are
+ * tried — inside the row's parent, then after each ancestor — so a drop on a leaf's edge that the
+ * leaf's own slot does not allow still finds a home. Pure: nothing is dispatched.
+ */
+export declare function treeDropTarget(input: TreeDropInput): TreeDropResult | undefined;
+//# sourceMappingURL=tree-target.d.ts.map

package/dist/dnd/tree-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree-target.d.ts","sourceRoot":"","sources":["../../src/dnd/tree-target.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EAGpB,KAAK,QAAQ,EACb,KAAK,UAAU,EAEf,KAAK,MAAM,EACX,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAI5D,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEzD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IACnC,4FAA4F;IAC5F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,6FAA6F;IAC7F,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,GAAG,EAAE,eAAe,CAAC;IAC9B,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,mFAAmF;IACnF,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAKD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS,CA4E/E"}

package/dist/dnd/tree-target.js

@@ -0,0 +1,97 @@
+import { canInsert, createIndex, } from '@next-buildr/core';
+import { moveVerdict } from './check.js';
+import { fragmentFor } from './fragment.js';
+/** The share of a row that counts as its edge; the middle is "inside". */
+const EDGE = 0.25;
+/**
+ * Where a drop over the layers tree would land: the row under the pointer picks the spot (its top
+ * quarter is before it, its bottom quarter after it, the middle inside it) and the rules
+ * (`canInsert`/`canMove`) accept or refuse it. When they refuse, the nearest legal alternatives are
+ * tried — inside the row's parent, then after each ancestor — so a drop on a leaf's edge that the
+ * leaf's own slot does not allow still finds a home. Pure: nothing is dispatched.
+ */
+export function treeDropTarget(input) {
+    const { doc, registry, rows, item, y, rowHeight } = input;
+    if (rows.length === 0 || !(rowHeight > 0))
+        return undefined;
+    const rowIndex = Math.min(rows.length - 1, Math.max(0, Math.floor(y / rowHeight)));
+    const row = rows[rowIndex];
+    if (row === undefined)
+        return undefined;
+    const within = y / rowHeight - rowIndex;
+    const isRoot = row.parentId === null;
+    const position = isRoot
+        ? 'inside'
+        : within < EDGE
+            ? 'before'
+            : within > 1 - EDGE
+                ? 'after'
+                : 'inside';
+    const index = createIndex(doc);
+    const fragment = item.kind === 'nodes' ? undefined : fragmentFor(registry, item);
+    if (item.kind !== 'nodes' && fragment === undefined) {
+        return { target: null, rowIndex, position };
+    }
+    const ids = item.kind === 'nodes' ? item.ids : [];
+    const endOf = (parentId, slot) => {
+        const children = doc.nodes[parentId]?.slots?.[slot] ?? [];
+        // Moving out of the same slot leaves one gap less than the count.
+        return children.length;
+    };
+    const beside = (id, offset) => {
+        const parentId = index.parentOf[id];
+        const slot = index.slotOf[id];
+        const at = index.indexOf[id];
+        return parentId === undefined || slot === undefined || at === undefined
+            ? undefined
+            : { parentId, slot, index: at + offset };
+    };
+    const candidates = [];
+    const push = (target) => {
+        if (target !== undefined)
+            candidates.push(target);
+    };
+    const inside = () => {
+        const slots = new Set(['default', ...Object.keys(doc.nodes[row.id]?.slots ?? {})]);
+        for (const slot of slots)
+            push({ parentId: row.id, slot, index: endOf(row.id, slot) });
+    };
+    if (position === 'inside')
+        inside();
+    else
+        push(beside(row.id, position === 'before' ? 0 : 1));
+    if (position !== 'inside')
+        inside();
+    else if (!isRoot)
+        push(beside(row.id, 1));
+    for (let up = index.parentOf[row.id]; up !== undefined; up = index.parentOf[up]) {
+        if (up === doc.root)
+            break;
+        // Right after a node that is itself being moved is where it already is.
+        if (!ids.includes(up))
+            push(beside(up, 1));
+    }
+    let firstRefusal;
+    for (const target of candidates) {
+        const place = { parentId: target.parentId, slot: target.slot, at: target.index };
+        let verdict;
+        if (fragment !== undefined) {
+            verdict = canInsert(doc, index, registry, place, fragment);
+        }
+        else {
+            // Every dragged node must be allowed there; the first that is not gives the reason.
+            verdict = { ok: true, value: true };
+            for (const id of ids) {
+                const one = moveVerdict(doc, index, registry, id, target);
+                if (!one.ok) {
+                    verdict = one;
+                    break;
+                }
+            }
+        }
+        if (verdict.ok)
+            return { target, rowIndex, position };
+        firstRefusal ??= verdict.error;
+    }
+    return { target: null, rowIndex, position, reason: firstRefusal };
+}

package/dist/fonts/LICENSE-inter.txt

@@ -0,0 +1,93 @@
+Copyright 2016 The Inter Project Authors (https://github.com/rsms/inter) Inter-Italic[opsz,wght].ttf: Copyright 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { BuilderEditor } from './app/builder-editor.tsx';
+export type { BreakpointConfig, BuilderEditorProps, DocumentRef, EditorConfig, ResolvedEditorConfig, } from './app/config.ts';
+export { DEFAULT_BREAKPOINTS, resolveConfig } from './app/config.ts';
+export type { EditorAppProps } from './app/editor-app.tsx';
+export { EditorApp } from './app/editor-app.tsx';
+export type { EditorLayoutProps } from './app/layout.tsx';
+export { EditorLayout } from './app/layout.tsx';
+export { ManifestProvider, useManifest } from './app/manifest.tsx';
+export * from './canvas-host/index.ts';
+export * from './clipboard/index.ts';
+export * from './dialogs/index.ts';
+export * from './dnd/index.ts';
+export type { MessageKey, Messages, Translate, UiLocale } from './messages/index.tsx';
+export { createTranslator, MessagesProvider, UI_LOCALES, useT } from './messages/index.tsx';
+export * from './panels/index.ts';
+export * from './persistence/index.ts';
+export * from './preview/index.ts';
+export * from './shortcuts/index.ts';
+export * from './store/index.ts';
+export * from './toolbar/index.ts';
+export * from './ui/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,YAAY,EACV,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,EACX,YAAY,EACZ,oBAAoB,GACrB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrE,YAAY,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,YAAY,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACnE,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAC5F,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC"}

package/dist/index.js

@@ -0,0 +1,21 @@
+// Public entry point of @next-buildr/editor: the standalone visual editor application.
+// Depends only on @next-buildr/core - it drives a canvas (a real Next.js route running the
+// real renderer) through the postMessage protocol; it never renders the document itself.
+// Import '@next-buildr/editor/styles.css' once in the host.
+export { BuilderEditor } from './app/builder-editor.js';
+export { DEFAULT_BREAKPOINTS, resolveConfig } from './app/config.js';
+export { EditorApp } from './app/editor-app.js';
+export { EditorLayout } from './app/layout.js';
+export { ManifestProvider, useManifest } from './app/manifest.js';
+export * from './canvas-host/index.js';
+export * from './clipboard/index.js';
+export * from './dialogs/index.js';
+export * from './dnd/index.js';
+export { createTranslator, MessagesProvider, UI_LOCALES, useT } from './messages/index.js';
+export * from './panels/index.js';
+export * from './persistence/index.js';
+export * from './preview/index.js';
+export * from './shortcuts/index.js';
+export * from './store/index.js';
+export * from './toolbar/index.js';
+export * from './ui/index.js';