@felbrasil/dreamy 0.0.0-stage → 0.1.1

package/dist/types/module/src/ui/hooks/use-editor-controller.d.ts

@@ -0,0 +1,17 @@
+import type { CreationApi, Id, LibrarySync, Persistence, PreferencesStore, Viewport } from "../../../../api/src/index.js";
+import type { Editor } from "./editor-context.js";
+export type EditorControllerProps = {
+    readonly api: CreationApi;
+    readonly viewport: Viewport;
+    readonly persistence: Persistence;
+    readonly preferences: PreferencesStore;
+    readonly creationId: Id;
+    readonly onOpen: (id: Id) => void;
+    /** Git sync of the library, when the host offers it (Scenes dialog). */
+    readonly sync?: LibrarySync;
+};
+/** The page's state: the folded creation, the view state, toasts, stats, autosave and the Esc hold. */
+export declare function useEditorController(props: EditorControllerProps): Editor & {
+    escDown(): void;
+    escUp(cancelled?: boolean): void;
+};

package/dist/types/module/src/ui/hooks/use-keyboard.d.ts

@@ -0,0 +1,11 @@
+import type { Editor } from "./editor-context.js";
+type KeyboardEditor = Editor & {
+    escDown(): void;
+    escUp(cancelled?: boolean): void;
+};
+/**
+ * The studio's UI-level shortcuts (the POC help panel): ? help, Esc steps / hold, Ctrl+Z / Y / D, Delete,
+ * E cycle mode, + / − size, and , . F for the decal brush. Camera keys (WASD), Space and Q stay with the viewport.
+ */
+export declare function useKeyboard(editor: KeyboardEditor): void;
+export {};

package/dist/types/module/src/ui/lib/catalog.d.ts

@@ -0,0 +1,76 @@
+import type { BodyRegion, FleckShape, PatternKind, StampMode, StampShape, ViewPreferences, WingOutline, WingPatternStyle } from "../../../../api/src/index.js";
+/** An icon: a Font Awesome solid icon name, a text glyph, or a 24 × 24 outline path. */
+export type IconSpec = {
+    readonly fa: string;
+    readonly rotate?: number;
+} | {
+    readonly glyph: string;
+} | {
+    readonly path: string;
+};
+export type StampShapeInfo = {
+    readonly id: StampShape;
+    readonly name: string;
+    readonly bg: string;
+    readonly icon: IconSpec;
+    /** Smaller icon used in the shape list. */
+    readonly listIcon: IconSpec;
+};
+export declare const STAMP_SHAPES: readonly StampShapeInfo[];
+export declare function stampShapeInfo(shape: StampShape): StampShapeInfo;
+export type ModeInfo = {
+    readonly id: StampMode;
+    readonly name: string;
+    readonly color: string;
+    readonly icon: IconSpec;
+};
+export declare const STAMP_MODES: readonly ModeInfo[];
+/** The list badge shows ∩ for intersect, as in the POC. */
+export declare const MODE_BADGE: {
+    readonly [Mode in StampMode]: IconSpec;
+};
+export declare function modeInfo(mode: StampMode): ModeInfo;
+export type FleckShapeInfo = {
+    readonly id: FleckShape;
+    readonly name: string;
+    readonly icon: IconSpec;
+};
+export declare const FLECK_SHAPES: readonly FleckShapeInfo[];
+/** The quick fleck buttons of the Fleck Style bar. */
+export declare const QUICK_FLECKS: readonly {
+    readonly id: FleckShape;
+    readonly name: string;
+    readonly fa: string;
+}[];
+export declare const PATTERNS: readonly {
+    readonly id: PatternKind;
+    readonly name: string;
+}[];
+export declare const WING_OUTLINES: readonly {
+    readonly id: WingOutline;
+    readonly name: string;
+}[];
+export declare const WING_STYLES: readonly {
+    readonly id: WingPatternStyle;
+    readonly name: string;
+}[];
+export declare const RENDER_RESOLUTIONS: readonly {
+    readonly id: ViewPreferences["renderResolution"];
+    readonly name: string;
+}[];
+export declare const BODY_REGIONS: readonly {
+    readonly id: BodyRegion;
+    readonly name: string;
+}[];
+/** Decal picker categories: the built-ins, then the creation's designs. */
+export declare const DECAL_CATEGORIES: readonly {
+    readonly id: string;
+    readonly name: string;
+    readonly fa: string;
+}[];
+/** Brush and decal size range (the size panel, + / − keys). */
+export declare const SIZE_MIN = 0.15;
+export declare const SIZE_MAX = 4;
+/** Kaleidoscope copies per axis: the control's range (the core clamps further). */
+export declare const SYMMETRY_MAX = 12;
+export declare const MAX_BONES = 64;

package/dist/types/module/src/ui/lib/colors.d.ts

@@ -0,0 +1,15 @@
+import type { ColorRef, FixedColor, Palette, PaletteSlot, Rgb } from "../../../../api/src/index.js";
+/** The editable slots, in swatch order. */
+export declare const PALETTE_SLOTS: readonly PaletteSlot[];
+/** The fixed colors, shown after the slots with a dark ring. */
+export declare const FIXED_COLORS: readonly FixedColor[];
+export declare const COLOR_REFS: readonly ColorRef[];
+export declare const COLOR_NAMES: {
+    readonly [Ref in ColorRef]: string;
+};
+export declare function isFixedColor(ref: ColorRef): ref is FixedColor;
+export declare function refRgb(palette: Palette, ref: ColorRef): Rgb;
+export declare function rgbHex(rgb: Rgb): string;
+export declare function refHex(palette: Palette, ref: ColorRef): string;
+/** "#rrggbb" from a color input; undefined when it is not one. */
+export declare function hexRgb(hex: string): Rgb | undefined;

package/dist/types/module/src/ui/lib/decals.d.ts

@@ -0,0 +1,6 @@
+import type { DecalArt, DecalCatalogEntry } from "../../../../api/src/index.js";
+export type CatalogEntry = DecalCatalogEntry & {
+    readonly category: string;
+};
+export declare function sameArt(a: DecalArt | undefined, b: DecalArt | undefined): boolean;
+export declare function isInterior(art: DecalArt | undefined): boolean;

package/dist/types/module/src/ui/lib/design-geometry.d.ts

@@ -0,0 +1,60 @@
+import type { DesignPaint, DesignShape, Palette } from "../../../../api/src/index.js";
+/**
+ * The decal editor's working model. A design stores SVG `d` strings in a 128 × 128 space; the editor turns them
+ * into editable paths (polylines, ellipses as 4 conjugate anchors, smooth Catmull-Rom curves) and back. Paths it
+ * cannot read stay `raw`: shown and restyled, never reshaped. Mirror twins are regenerated from their source.
+ */
+export declare const DESIGN_SIZE = 128;
+export declare const GRID = 4;
+export declare const MAX_POINTS = 120;
+export type Point = readonly [number, number];
+export type EditorPath = {
+    readonly kind: "poly";
+    readonly points: readonly Point[];
+    readonly closed: boolean;
+    readonly smooth: boolean;
+} | {
+    readonly kind: "ellipse";
+    readonly points: readonly Point[];
+} | {
+    readonly kind: "raw";
+    readonly d: string;
+};
+export type EditorShape = {
+    readonly id: string;
+    readonly paths: readonly EditorPath[];
+    readonly fill: DesignPaint;
+    readonly stroke: DesignPaint;
+    readonly width: number;
+    readonly cap: DesignShape["cap"];
+    readonly join: DesignShape["join"];
+    readonly rule: DesignShape["rule"];
+    readonly mirror: boolean;
+};
+export type Box = {
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+};
+export declare function pathD(path: EditorPath): string;
+export declare function shapeD(shape: EditorShape): string;
+export declare function mirrorPath(path: EditorPath): EditorPath | undefined;
+export declare function twinD(shape: EditorShape): string | undefined;
+export declare function canTransform(shape: EditorShape): boolean;
+export declare function pathBounds(path: EditorPath): Box | undefined;
+export declare function unionBox(a: Box | undefined, b: Box | undefined): Box | undefined;
+export declare function shapeBounds(shape: EditorShape): Box | undefined;
+export declare function shapesBounds(shapes: readonly EditorShape[]): Box | undefined;
+/** Maps every point of the shapes (raw paths stay). */
+export declare function mapShapes(shapes: readonly EditorShape[], ids: ReadonlySet<string>, f: (q: Point) => Point): readonly EditorShape[];
+/** Star (alternating radius) or regular polygon points around a center. */
+export declare function polygonPoints(tool: "star" | "ngon", center: Point, radius: number, sides: number, ratio: number): readonly Point[];
+/** Reads `d` back into editable paths; anything but M / L / H / V / C / Z (absolute or relative) stays raw. */
+export declare function parseD(d: string): readonly EditorPath[];
+/** A design's shapes as editor shapes (twins fold back into a mirror flag on their source). */
+export declare function loadDesignShapes(shapes: readonly DesignShape[], nextId: () => string): readonly EditorShape[];
+/** What is saved: every shape, each mirrored one followed by its twin. */
+export declare function flattenShapes(shapes: readonly EditorShape[]): readonly DesignShape[];
+/** CSS color of a design paint. */
+export declare function paintColor(palette: Palette, paint: DesignPaint): string;

package/dist/types/module/src/ui/lib/math.d.ts

@@ -0,0 +1,18 @@
+import type { Quaternion, Transform, Vec3 } from "../../../../api/src/index.js";
+export declare const IDENTITY_QUATERNION: Quaternion;
+export declare const ZERO: Vec3;
+export declare const ONE: Vec3;
+export declare function identityTransform(position?: Vec3): Transform;
+/** Euler angles in degrees (XYZ order, as the POC's Transform tab) to a quaternion. */
+export declare function quaternionFromDegrees(angles: Vec3): Quaternion;
+/** A quaternion to Euler angles in degrees (XYZ order). */
+export declare function degreesFromQuaternion(q: Quaternion): Vec3;
+export declare function multiplyQuaternions(a: Quaternion, b: Quaternion): Quaternion;
+export declare function invertQuaternion(q: Quaternion): Quaternion;
+export declare function addVec(a: Vec3, b: Vec3): Vec3;
+export declare function subVec(a: Vec3, b: Vec3): Vec3;
+export declare function mulVec(a: Vec3, b: Vec3): Vec3;
+/** Per-axis ratio new / old (1 where the old value is zero). */
+export declare function ratioVec(next: Vec3, old: Vec3): Vec3;
+export declare function averageVec(points: readonly Vec3[]): Vec3;
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/types/module/src/ui/lib/placement.d.ts

@@ -0,0 +1,8 @@
+import type { Creation, SceneObject, Vec3 } from "../../../../api/src/index.js";
+/** Where a new standalone rig goes: the origin, stepped along x past nearby root objects. */
+export declare function spawnPoint(creation: Creation): Vec3;
+/** The content box a premade is fitted to, in the object's space (from its stamps). */
+export declare function contentFit(object: SceneObject): {
+    readonly center: Vec3;
+    readonly halfSize: Vec3;
+};

package/dist/types/module/src/ui/lib/scene.d.ts

@@ -0,0 +1,51 @@
+import type { BodyPart, Bone, Creation, Design, Id, RigObject, SceneObject, Sculpt, SculptTarget, SmearGroup, Stamp, Vec3 } from "../../../../api/src/index.js";
+/** Read-only lookups over a folded creation. No rule of the domain lives here. */
+export declare function objectById(creation: Creation, id: Id | undefined): SceneObject | undefined;
+export declare function rigById(creation: Creation, id: Id | undefined): RigObject | undefined;
+/** Objects under a parent (undefined: the scene root), in scene order. */
+export declare function childrenOf(creation: Creation, parentId: Id | undefined): readonly SceneObject[];
+export declare function boneOf(rig: RigObject, boneId: Id | undefined): Bone | undefined;
+export declare function partOf(rig: RigObject, boneId: Id | undefined): BodyPart | undefined;
+/** The sculpt a target names: a sculpt object, a rig's skinned body, or a bone's sculpt part. */
+export declare function sculptOf(creation: Creation, target: SculptTarget | undefined): Sculpt | undefined;
+export declare function sameTarget(a: SculptTarget | undefined, b: SculptTarget | undefined): boolean;
+export declare function targetBone(target: SculptTarget | undefined): Id | undefined;
+/** Every sculpt target an object owns: its own sculpt, a rig's body and its sculpt parts. */
+export declare function sculptTargetsOf(object: SceneObject): readonly SculptTarget[];
+/** Bones in tree order (depth first, children in list order), with their depth. */
+export declare function boneTree(rig: RigObject): readonly {
+    readonly bone: Bone;
+    readonly depth: number;
+}[];
+/** Object ids of an object and everything under it. */
+export declare function subtreeIds(creation: Creation, id: Id): readonly Id[];
+export declare function groupOf(sculpt: Sculpt, stamp: Stamp | undefined): SmearGroup | undefined;
+export declare function groupMembers(sculpt: Sculpt, groupId: Id): readonly Stamp[];
+export type StampRow = {
+    readonly kind: "stamp";
+    readonly stamp: Stamp;
+    readonly index: number;
+} | {
+    readonly kind: "group";
+    readonly group: SmearGroup;
+    readonly members: readonly {
+        readonly stamp: Stamp;
+        readonly index: number;
+    }[];
+};
+/** The shape list: loose stamps, and each smear group once where its first member sits. */
+export declare function stampRows(sculpt: Sculpt): readonly StampRow[];
+/** What one pick selects: a locked smear group selects all its stamps. */
+export declare function pickStamp(sculpt: Sculpt, stampId: Id): readonly Id[];
+/** The steps of the stamp stepper: locked groups count once. */
+export declare function stampSteps(sculpt: Sculpt): readonly (readonly Id[])[];
+/** The smear group a selection is exactly (all of its stamps and nothing else), if any. */
+export declare function selectedGroup(sculpt: Sculpt, stampIds: readonly Id[]): SmearGroup | undefined;
+/** Axis-aligned box of a sculpt's stamps in its local space (stamp rotation and symmetry ignored). */
+export declare function stampBounds(sculpt: Sculpt): {
+    readonly center: Vec3;
+    readonly halfSize: Vec3;
+} | undefined;
+/** Designs a set of sculpts places as decals. */
+export declare function designsUsedBy(creation: Creation, sculpts: readonly Sculpt[]): readonly Design[];
+export declare function sculptsOfObject(object: SceneObject): readonly Sculpt[];

package/dist/types/module/src/ui/lib/symmetry.d.ts

@@ -0,0 +1,5 @@
+import type { SymmetryAxis } from "../../../../api/src/index.js";
+/** The axes in x, y, z order with one toggled. */
+export declare function toggleAxis(axes: readonly SymmetryAxis[], axis: SymmetryAxis): readonly SymmetryAxis[];
+/** "Off" / "Y (default)" when no axis is chosen, blank once one is. */
+export declare function symmetryHint(count: number, axes: readonly SymmetryAxis[]): string;

package/dist/types/module/src/ui/lib/targets.d.ts

@@ -0,0 +1,28 @@
+import type { Command, Creation, Id, SculptTarget, SmearGroup, Stamp, StampPropsPatch } from "../../../../api/src/index.js";
+import type { ViewState } from "./view-state.js";
+/** The selected bone's part, when Rig Bones is active with one rig and a bone selected. */
+export declare function selectedBonePart(creation: Creation, view: ViewState): {
+    rig: import("../../../../api/src/index.js").RigObject;
+    part: import("../../../../api/src/index.js").BodyPart;
+} | undefined;
+/** What Properties' look tabs edit: the scoped sculpt, a bone's part (or all parts), or every selected object's sculpts. */
+export declare function lookTargets(creation: Creation, view: ViewState): readonly SculptTarget[];
+/** The flat wings the Wing tab edits: the selected bone's wing, or every wing with "All parts". */
+export declare function wingTargets(creation: Creation, view: ViewState): {
+    readonly rigId: Id;
+    readonly boneIds: readonly Id[];
+} | undefined;
+/** The settings owner of the selected shapes in sculpt mode: a whole smear group, or loose stamps. */
+export type StampSettings = {
+    readonly kind: "group";
+    readonly target: SculptTarget;
+    readonly group: SmearGroup;
+    readonly stamps: readonly Stamp[];
+} | {
+    readonly kind: "stamps";
+    readonly target: SculptTarget;
+    readonly stamps: readonly Stamp[];
+};
+export declare function stampSettings(creation: Creation, view: ViewState): StampSettings | undefined;
+/** The command that patches the selected shapes' settings (the group's when they are one group). */
+export declare function stampPropsCommand(settings: StampSettings, props: StampPropsPatch): Command;

package/dist/types/module/src/ui/lib/view-state.d.ts

@@ -0,0 +1,74 @@
+import type { BoneTool, Command, Creation, DecalBrush, Id, SculptTarget, Selection, StampBrush, Tool, ViewPreferences, ViewSession } from "../../../../api/src/index.js";
+export type Category = "transform" | "shape" | "style" | "decal" | "symmetry" | "skeleton" | "rendering" | "utilities";
+/** Panels that become bottom sheets in the compact layout (one shown at a time). */
+export type SheetKey = "properties" | "stampProps" | "palette" | "voxel" | "help" | "shapes" | "bones" | "objects";
+export type PropertiesTab = "transform" | "style" | "material" | "pattern" | "wing" | "pose" | "parts";
+export type TransformTool = "select" | "translate" | "rotate" | "scale" | "pivot";
+/** Everything the studio shows besides the creation. View state: never stored in the creation. */
+export type ViewState = {
+    readonly mode: "assembly" | "sculpt";
+    readonly scope?: SculptTarget;
+    readonly selection: Selection;
+    readonly category: Category;
+    readonly tool: Tool;
+    /** The Transform bar's tool, restored when the category comes back. */
+    readonly transformTool: TransformTool;
+    readonly space: "world" | "local";
+    readonly brush: StampBrush;
+    readonly decalBrush: DecalBrush;
+    readonly decalCategory: string;
+    readonly boneTool: BoneTool;
+    /** The pivot tool's gizmo: move or turn the pivot. */
+    readonly pivotGizmo: "translate" | "rotate";
+    /** Rigs whose bones are hidden (the object list's eye toggle). */
+    readonly hiddenBones: readonly Id[];
+    readonly touchArea: boolean;
+    readonly touchAdd: boolean;
+    readonly play: boolean;
+    readonly stressTest: boolean;
+    readonly prefs: ViewPreferences;
+    /** Floating panels the user opened. */
+    readonly open: {
+        readonly [Key in "properties" | "stampProps" | "palette" | "voxel" | "help"]: boolean;
+    };
+    /** Left-stack lists shrunk to their icon. */
+    readonly minimized: {
+        readonly [Key in "shapes" | "bones" | "objects"]: boolean;
+    };
+    /** Sheets in the order they were opened (newest last). */
+    readonly sheetOrder: readonly SheetKey[];
+    readonly propertiesTab: PropertiesTab;
+    readonly editAllParts: boolean;
+    readonly premadeOpen: boolean;
+    readonly scenesOpen: boolean;
+    /** The decal design editor: closed, a new design, or a design to edit. */
+    readonly decalEditor: null | {
+        readonly designId?: Id;
+    };
+    /** Expanded rows of the object list. */
+    readonly expanded: readonly Id[];
+};
+export declare const EMPTY_SELECTION: Selection;
+export declare const DEFAULT_BRUSH: StampBrush;
+export declare const DEFAULT_DECAL_BRUSH: DecalBrush;
+export declare function initialViewState(prefs: ViewPreferences, compact: boolean): ViewState;
+/** What the viewport is sent with every change. */
+export declare function viewSession(view: ViewState): ViewSession;
+/** Opens or closes a sheet panel, keeping the compact sheet order. */
+export declare function withSheet(view: ViewState, key: SheetKey, open: boolean): ViewState;
+export declare function isSculptScopeSymmetric(view: ViewState): boolean;
+/** Which categories the bar shows: Symmetry only in a sculpt (not a body part), Rig Bones only in assembly. */
+export declare function categoryVisible(view: ViewState, category: Category): boolean;
+export declare function selectCategory(view: ViewState, category: Category): ViewState;
+export declare function setTransformTool(view: ViewState, tool: TransformTool): ViewState;
+/** Scopes into a sculpt target: sculpt mode, Select tool, the first stamp selected. */
+export declare function enterScope(view: ViewState, creation: Creation, target: SculptTarget): ViewState;
+/** Leaves sculpt mode. A body part returns to its rig with the bone selected and Rig Bones open. */
+export declare function leaveScope(view: ViewState): ViewState;
+/** Drops ids that no longer exist; leaves a scope whose sculpt is gone. */
+export declare function pruneView(view: ViewState, creation: Creation): ViewState;
+/** After an accepted command: select what it created (new root objects, new stamps in scope, a new bone). */
+export declare function selectCreated(view: ViewState, before: Creation, after: Creation, command: Command): ViewState;
+/** In the compact layout only the newest open sheet is drawn. */
+export declare function sheetHidden(view: ViewState, compact: boolean, key: SheetKey): boolean;
+export declare function anySheetOpen(view: ViewState, compact: boolean): boolean;

package/dist/types/module/src/ui/molecules/axis-pill.d.ts

@@ -0,0 +1,7 @@
+import type { SymmetryAxis } from "../../../../api/src/index.js";
+export type AxisPillProps = {
+    readonly axes: readonly SymmetryAxis[];
+    readonly onToggle: (axis: SymmetryAxis) => void;
+};
+/** The X / Y / Z kaleidoscope axis toggles. */
+export declare function AxisPill({ axes, onToggle }: AxisPillProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/color-field.d.ts

@@ -0,0 +1,14 @@
+import type { ColorRef, Palette, PaletteSlot, Rgb } from "../../../../api/src/index.js";
+import type { ReactNode } from "react";
+export type ColorFieldProps = {
+    readonly label: string;
+    readonly palette: Palette;
+    readonly value: ColorRef;
+    /** Next to the label (Match, Inherit). */
+    readonly extra?: ReactNode | undefined;
+    readonly onPick: (ref: ColorRef) => void;
+    /** The picker edits the referenced slot (fixed colors cannot be edited). */
+    readonly onEditSlot: (slot: PaletteSlot, color: Rgb) => void;
+};
+/** A labelled color choice: the slot picker plus the swatch grid. */
+export declare function ColorField({ label, palette, value, extra, onPick, onEditSlot }: ColorFieldProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/count-stepper.d.ts

@@ -0,0 +1,9 @@
+export type CountStepperProps = {
+    readonly label: string;
+    readonly value: number;
+    readonly min: number;
+    readonly max: number;
+    readonly onChange: (value: number) => void;
+};
+/** − n + */
+export declare function CountStepper({ label, value, min, max, onChange }: CountStepperProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/floating-panel.d.ts

@@ -0,0 +1,26 @@
+import { type CSSProperties, type ReactNode } from "react";
+/** The z-order counter shared by one studio's panels (a click raises a panel). */
+export declare const PanelLayerContext: import("react").Context<{
+    top: number;
+}>;
+export type FloatingPanelProps = {
+    readonly id: string;
+    readonly title: ReactNode;
+    readonly icon?: string | undefined;
+    readonly className?: string | undefined;
+    /** Header buttons before the close button. */
+    readonly headerExtra?: ReactNode | undefined;
+    /** Hidden by the compact layout (another sheet is on top). */
+    readonly sheetHidden?: boolean | undefined;
+    /** Dragging is off in the compact layout. */
+    readonly draggable?: boolean | undefined;
+    readonly headerClassName?: string | undefined;
+    readonly style?: CSSProperties | undefined;
+    readonly children: ReactNode;
+    readonly onClose?: () => void;
+    readonly onDragOver?: (event: React.DragEvent) => void;
+    readonly onDragLeave?: (event: React.DragEvent) => void;
+    readonly onDrop?: (event: React.DragEvent) => void;
+};
+/** A frosted panel that moves by its header, stays inside the window and comes to the front on click. */
+export declare function FloatingPanel({ id, title, icon, className, headerExtra, sheetHidden, draggable, headerClassName, style, children, onClose, onDragOver, onDragLeave, onDrop, }: FloatingPanelProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/help-row.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+export declare function HelpSection({ children }: {
+    readonly children: ReactNode;
+}): import("react").JSX.Element;
+export declare function HelpRow({ keys, children }: {
+    readonly keys: ReactNode;
+    readonly children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/inline-edit.d.ts

@@ -0,0 +1,9 @@
+export type InlineEditProps = {
+    readonly value: string;
+    readonly label: string;
+    readonly maxLength?: number | undefined;
+    readonly onCommit: (value: string) => void;
+    readonly onCancel: () => void;
+};
+/** A text field that replaces a name while renaming: Enter or blur commits, Esc cancels. */
+export declare function InlineEdit({ value, label, maxLength, onCommit, onCancel }: InlineEditProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/list-row.d.ts

@@ -0,0 +1,25 @@
+import type { DragEvent, ReactNode } from "react";
+import type { IconSpec } from "../lib/catalog.js";
+export type ListRowProps = {
+    readonly name: ReactNode;
+    readonly icon: string | IconSpec;
+    readonly iconBg?: string | undefined;
+    readonly selected?: boolean | undefined;
+    /** "group" (pink smear group) or "member" (indented). */
+    readonly variant?: "group" | "member" | undefined;
+    /** Left indent in pixels. */
+    readonly indent?: number | undefined;
+    readonly lead?: ReactNode | undefined;
+    readonly children?: ReactNode | undefined;
+    readonly dropTarget?: boolean | undefined;
+    readonly draggable?: boolean | undefined;
+    readonly onClick?: () => void;
+    readonly onDoubleClick?: () => void;
+    readonly onDragStart?: (event: DragEvent) => void;
+    readonly onDragEnd?: () => void;
+    readonly onDragOver?: (event: DragEvent) => void;
+    readonly onDragLeave?: (event: DragEvent) => void;
+    readonly onDrop?: (event: DragEvent) => void;
+};
+/** One row of the shape, bone and object lists. Buttons go in `children`. */
+export declare function ListRow({ name, icon, iconBg, selected, variant, indent, lead, children, dropTarget, draggable, onClick, onDoubleClick, onDragStart, onDragEnd, onDragOver, onDragLeave, onDrop, }: ListRowProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/modal.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from "react";
+export type ModalProps = {
+    readonly id: string;
+    readonly label: string;
+    readonly cardClassName: string;
+    readonly children: ReactNode;
+    /** A click on the backdrop (outside the card). */
+    readonly onBackdrop?: () => void;
+};
+/** A centered card over a blurred backdrop. */
+export declare function Modal({ id, label, cardClassName, children, onBackdrop }: ModalProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/mode-pill.d.ts

@@ -0,0 +1,7 @@
+import type { StampMode } from "../../../../api/src/index.js";
+export type ModePillProps = {
+    readonly value: StampMode;
+    readonly onChange: (mode: StampMode) => void;
+};
+/** Add / Subtract / Intersect / Paint. */
+export declare function ModePill({ value, onChange }: ModePillProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/scroll-row.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from "react";
+export type ScrollRowProps = {
+    readonly label: string;
+    readonly children: ReactNode;
+};
+/**
+ * A long toolbar section that scrolls sideways: edge fades and chevrons when there is more, wheel scrolling,
+ * and one shared tooltip (tooltips inside a scroller would be clipped).
+ */
+export declare function ScrollRow({ label, children }: ScrollRowProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/slider-row.d.ts

@@ -0,0 +1,16 @@
+export type SliderRowProps = {
+    readonly label: string;
+    readonly value: number;
+    readonly min: number;
+    readonly max: number;
+    readonly step?: number | undefined;
+    readonly digits?: number | undefined;
+    readonly suffix?: string | undefined;
+    /** Greyed out and inert (fleck sliders while flecks are off). */
+    readonly off?: boolean | undefined;
+    /** Shows the value in blue (a per-shape override). */
+    readonly own?: boolean | undefined;
+    readonly onCommit: (value: number) => void;
+};
+/** Label, live value and a range input that commits on release. */
+export declare function SliderRow({ label, value, min, max, step, digits, suffix, off, own, onCommit }: SliderRowProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/swatch-row.d.ts

@@ -0,0 +1,11 @@
+import type { ColorRef, Palette } from "../../../../api/src/index.js";
+export type SwatchRowProps = {
+    readonly palette: Palette;
+    readonly active?: ColorRef | undefined;
+    /** Fixed pixel size: a row (toolbars). Without it: a 10-column grid (panels). */
+    readonly size?: number | undefined;
+    readonly label: string;
+    readonly onPick: (ref: ColorRef) => void;
+};
+/** One swatch per palette slot, then the fixed colors. */
+export declare function SwatchRow({ palette, active, size, label, onPick }: SwatchRowProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/tab-bar.d.ts

@@ -0,0 +1,9 @@
+export type TabBarProps<Tab extends string> = {
+    readonly tabs: readonly {
+        readonly id: Tab;
+        readonly name: string;
+    }[];
+    readonly active: Tab;
+    readonly onSelect: (tab: Tab) => void;
+};
+export declare function TabBar<Tab extends string>({ tabs, active, onSelect }: TabBarProps<Tab>): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/toolbar-pill.d.ts

@@ -0,0 +1,7 @@
+import type { ReactNode } from "react";
+/** A labelled pill inside a toolbar ("Blend", "Copies", "Mode"). */
+export declare function ToolbarPill({ label, children, title }: {
+    readonly label: string;
+    readonly title?: string;
+    readonly children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/toolbar.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from "react";
+export type ToolbarProps = {
+    readonly id: string;
+    readonly label: string;
+    /** Sub-toolbars sit under the category bar. */
+    readonly sub?: boolean | undefined;
+    readonly children: ReactNode;
+};
+/** A frosted toolbar row. */
+export declare function Toolbar({ id, label, sub, children }: ToolbarProps): import("react").JSX.Element;

package/dist/types/module/src/ui/molecules/vec3-field.d.ts

@@ -0,0 +1,10 @@
+import type { Vec3 } from "../../../../api/src/index.js";
+export type Vec3FieldProps = {
+    readonly label: string;
+    readonly value: Vec3;
+    readonly step?: number | undefined;
+    readonly digits?: number | undefined;
+    readonly onCommit: (value: Vec3) => void;
+};
+/** Three number inputs (x, y, z); each commits the whole vector. */
+export declare function Vec3Field({ label, value, step, digits, onCommit }: Vec3FieldProps): import("react").JSX.Element;

package/dist/types/module/src/ui/organisms/bone-panel.d.ts

@@ -0,0 +1,2 @@
+/** The selected rig's bone tree (Rig Bones): select, rename, drag to reparent, parts, region blends, tags. */
+export declare function BonePanel(): import("react").JSX.Element | null;

package/dist/types/module/src/ui/organisms/bone-size-sliders.d.ts

@@ -0,0 +1,9 @@
+import type { Bone, Id } from "../../../../api/src/index.js";
+/**
+ * The selected bone's proportions: Length (its child joints move with it) and Thickness. A head starts at its made
+ * size and can only grow; the core enforces that, the sliders only start there.
+ */
+export declare function BoneSizeSliders({ rigId, bone }: {
+    readonly rigId: Id;
+    readonly bone: Bone;
+}): import("react").JSX.Element;

package/dist/types/module/src/ui/organisms/category-bar.d.ts

@@ -0,0 +1,2 @@
+/** The main bar: Scenes (the file menu), category tiles, then undo / redo. */
+export declare function CategoryBar(): import("react").JSX.Element;

package/dist/types/module/src/ui/organisms/decal-bar.d.ts

@@ -0,0 +1,2 @@
+/** Decals: category, art (from the viewport's catalog, with the creation's designs), tint, depth, flip, roll, eraser. */
+export declare function DecalBar(): import("react").JSX.Element;

package/dist/types/module/src/ui/organisms/decal-editor.d.ts

@@ -0,0 +1,2 @@
+/** The decal design editor (modal): a small vector editor whose Save dispatches SaveDesign. */
+export declare function DecalEditor(): import("react").JSX.Element | null;