@weasel-js/labkit 1.3.0-pre.0 → 1.4.0-pre.0

package/dist/_dts/index-BDVzvRzQ.d.ts

@@ -0,0 +1,236 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { R as ResolvedConfig, C as ConfigField, c as ControlRenderer } from './types-D6s4b7if.js';
+
+/** Props for `<PropertyPanel>`. */
+interface PropertyPanelProps {
+    title?: ReactNode;
+    children: ReactNode;
+    className?: string;
+}
+/** A titled panel holding property rows — the sidebar container the rest of
+ *  this module's components fill. */
+declare function PropertyPanel({ title, children, className }: PropertyPanelProps): react_jsx_runtime.JSX.Element;
+/** How a property list packs its rows into two columns. */
+type PropertyListPack = 'auto-color' | 'pairs';
+/** Props for `<PropertyList>`. */
+interface PropertyListProps {
+    children: ReactNode;
+    className?: string;
+    /**
+     * How rows pack into the 2-column grid.
+     *   - `'auto-color'` (default): only color rows pair side-by-side; everything
+     *     else spans the full width. Right for sparse top-level panels.
+     *   - `'pairs'`: every row auto-places into the 2-column grid two-per-row.
+     *     Headers and subpanels still span the full width; wrap any other
+     *     full-width child in `<PropertySpan>`. Right for dense effect bodies.
+     */
+    pack?: PropertyListPack;
+}
+/**
+ * Grid container for PropertyRows. Use standalone for chrome-less layouts, or
+ * nest inside <PropertyPanel/> for the standard glass card.
+ */
+declare function PropertyList({ children, className, pack }: PropertyListProps): react_jsx_runtime.JSX.Element;
+/** Props for `<PropertySpan>`. */
+interface PropertySpanProps {
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * Wrapper that makes an arbitrary child span both columns of a
+ * `<PropertyList pack="pairs">`, a `<PropertyGroup pack="pairs">` body, or a
+ * `<Subpanel>`. `<PropertyRow span>` covers the row case; this covers
+ * everything else a consumer puts in the grid.
+ */
+declare function PropertySpan({ children, className }: PropertySpanProps): react_jsx_runtime.JSX.Element;
+/** Which control shape a row holds, which decides its intrinsic layout. */
+type PropertyRowVariant = 'default' | 'color' | 'checkbox';
+/** Whether a row's label sits above its control or beside it. */
+type PropertyRowLayout = 'block' | 'inline';
+/** Props for `<PropertyRow>`. */
+interface PropertyRowProps {
+    label: ReactNode;
+    /** Right-aligned readout shown next to the label (e.g. current value). */
+    readout?: ReactNode;
+    /**
+     * Help text for the row, shown in a tooltip off an ⓘ affordance beside the
+     * label. Empty or absent renders no affordance.
+     */
+    description?: string;
+    variant?: PropertyRowVariant;
+    /**
+     * Label position relative to the control. "block" (default) stacks
+     * label above control; "inline" places the label to the left.
+     * Color and checkbox variants are always inline by their own nature.
+     */
+    layout?: PropertyRowLayout;
+    /**
+     * Take the full width of the enclosing grid. Only has an effect inside a
+     * `<PropertyList pack="pairs">` or a `<Subpanel>`; elsewhere rows are already
+     * full width.
+     */
+    span?: boolean;
+    children: ReactNode;
+    htmlFor?: string;
+    className?: string;
+}
+/** The label-plus-control frame every typed row below is built from. Use it
+ *  directly for a control this module does not cover. */
+declare function PropertyRow({ label, readout, description, variant, layout, span, children, htmlFor, className, }: PropertyRowProps): react_jsx_runtime.JSX.Element;
+/** Props for `<SliderRow>`. */
+interface SliderRowProps {
+    label: ReactNode;
+    value: number;
+    min: number;
+    max: number;
+    step?: number;
+    onChange: (next: number) => void;
+    /** Override how the value is rendered next to the label. Defaults to `value.toString()`. */
+    format?: (value: number) => ReactNode;
+    /**
+     * Optional suffix rendered next to the readout. A string becomes a
+     * baseline-aligned dim "word" unit (e.g. "px"); pass JSX like `<sup>°</sup>`
+     * to get the browser's native super positioning for symbol units.
+     */
+    unit?: ReactNode;
+    layout?: PropertyRowLayout;
+    description?: string;
+    /** Take the full width of the enclosing grid — see `<PropertyRow span>`. */
+    span?: boolean;
+}
+/** A bounded number edited by dragging, with a live readout whose precision
+ *  follows `step`. */
+declare function SliderRow({ label, value, min, max, step, onChange, format, unit, layout, description, span, }: SliderRowProps): react_jsx_runtime.JSX.Element;
+/** Props for `<ColorRow>`. */
+interface ColorRowProps {
+    label: ReactNode;
+    value: string;
+    onChange: (next: string) => void;
+    /** 0..1 alpha. When provided, a translucent slider renders beneath the swatch. */
+    alpha?: number;
+    onAlphaChange?: (next: number) => void;
+    /**
+     * Render the alpha track as inert (dimmed, no thumb, not-allowed cursor).
+     * Use when the color's consumer drops alpha so the affordance reads dead.
+     */
+    alphaDisabled?: boolean;
+    description?: string;
+    /** Take the full width of the enclosing grid — see `<PropertyRow span>`. */
+    span?: boolean;
+}
+/** A color swatch, optionally with an alpha slider beneath it. */
+declare function ColorRow({ label, value, onChange, alpha, onAlphaChange, alphaDisabled, description, span, }: ColorRowProps): react_jsx_runtime.JSX.Element;
+/** Props for `<CheckboxRow>`. */
+interface CheckboxRowProps {
+    label: ReactNode;
+    value: boolean;
+    onChange: (next: boolean) => void;
+    description?: string;
+    /** Take the full width of the enclosing grid — see `<PropertyRow span>`. */
+    span?: boolean;
+}
+/** A boolean checkbox. */
+declare function CheckboxRow({ label, value, onChange, span, description }: CheckboxRowProps): react_jsx_runtime.JSX.Element;
+/** Props for `<TextRow>`. */
+interface TextRowProps {
+    label: ReactNode;
+    value: string;
+    onChange: (next: string) => void;
+    placeholder?: string;
+    maxLength?: number;
+    layout?: PropertyRowLayout;
+    description?: string;
+    /** Take the full width of the enclosing grid — see `<PropertyRow span>`. */
+    span?: boolean;
+}
+/** A single-line text input. */
+declare function TextRow({ label, value, onChange, placeholder, maxLength, layout, description, span, }: TextRowProps): react_jsx_runtime.JSX.Element;
+/** Props for `<NumberRow>`. */
+interface NumberRowProps {
+    label: ReactNode;
+    value: number;
+    onChange: (next: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    placeholder?: string;
+    layout?: PropertyRowLayout;
+    description?: string;
+    /** Take the full width of the enclosing grid — see `<PropertyRow span>`. */
+    span?: boolean;
+}
+/** A number typed directly. Reach for `<SliderRow>` when the range matters
+ *  more than the exact value. */
+declare function NumberRow({ label, value, onChange, min, max, step, placeholder, layout, description, span, }: NumberRowProps): react_jsx_runtime.JSX.Element;
+interface PropertyOption<T extends string> {
+    value: T;
+    label: ReactNode;
+}
+/** Props for `<SelectRow>`. */
+interface SelectRowProps<T extends string> {
+    label: ReactNode;
+    value: T;
+    options: ReadonlyArray<PropertyOption<T>>;
+    onChange: (next: T) => void;
+    layout?: PropertyRowLayout;
+    description?: string;
+    /** Take the full width of the enclosing grid — see `<PropertyRow span>`. */
+    span?: boolean;
+}
+/** A dropdown over a fixed set of choices. Prefer `<ToggleRow>` when there
+ *  are only two or three and they should all stay visible. */
+declare function SelectRow<T extends string>({ label, value, options, onChange, layout, description, span, }: SelectRowProps<T>): react_jsx_runtime.JSX.Element;
+/** Props for `<ToggleRow>`. */
+interface ToggleRowProps<T extends string> {
+    label: ReactNode;
+    value: T;
+    options: ReadonlyArray<PropertyOption<T>>;
+    onChange: (next: T) => void;
+    layout?: PropertyRowLayout;
+    description?: string;
+    /** Take the full width of the enclosing grid — see `<PropertyRow span>`. */
+    span?: boolean;
+}
+/** A segmented control: the same choice as a select, with every option
+ *  visible at once. */
+declare function ToggleRow<T extends string>({ label, value, options, onChange, layout, description, span, }: ToggleRowProps<T>): react_jsx_runtime.JSX.Element;
+
+/** How a panel packs its rows into the two-column property grid.
+ *   - `'auto'`: narrow controls (numbers, checkboxes, dropdowns, colours) sit
+ *     two per row; the ones that need the width — text, sliders, segmented
+ *     toggles — span it.
+ *   - `'pairs'`: every row pairs. A control that needs the full width says so
+ *     itself, with `<PropertyRow span>`.
+ *   - `'one-up'`: one control per row, colours excepted.
+ */
+type ControlPack = 'auto' | 'pairs' | 'one-up';
+interface ControlPanelProps<TC extends Record<string, unknown>> {
+    /** The instrument's resolved config schema. */
+    schema?: ResolvedConfig;
+    /** @deprecated Pass `schema`. A field list is adapted into one internally. */
+    fields?: ConfigField[];
+    config: TC;
+    setConfig: (key: keyof TC, value: unknown) => void;
+    /**
+     * Control overrides and app-defined kinds, PrefsForm-style. Keys are config
+     * paths (checked first) or leaf kinds. A renderer returning `null` collapses
+     * the row; entries override the built-in rows on collision.
+     */
+    renderers?: Record<string, ControlRenderer>;
+    /** How rows pack into the two-column grid. Defaults to `'pairs'`. */
+    pack?: ControlPack;
+    /** Where a row's label sits relative to its control. Defaults to `'block'`
+     *  — above it, which is what leaves a paired row room for its value. */
+    layout?: PropertyRowLayout;
+    /** Draw leaves marked `hidden`. */
+    showHidden?: boolean;
+    className?: string;
+}
+/** Render an instrument's config schema as a stack of controls, each writing
+ *  back through `setConfig`. Built on the property rows, so a lab's controls
+ *  are the same aligned, themed rows the rest of the kit uses. */
+declare function ControlPanel<TC extends Record<string, unknown>>({ schema, fields, config, setConfig, renderers, pack, layout, showHidden, className, }: ControlPanelProps<TC>): react_jsx_runtime.JSX.Element;
+
+export { CheckboxRow as C, NumberRow as N, PropertyList as P, SelectRow as S, TextRow as T, ColorRow as b, ControlPanel as d, PropertyPanel as i, PropertyRow as k, PropertySpan as o, SliderRow as r, ToggleRow as u };
+export type { CheckboxRowProps as a, ColorRowProps as c, NumberRowProps as e, PropertyListPack as f, PropertyListProps as g, PropertyOption as h, PropertyPanelProps as j, PropertyRowLayout as l, PropertyRowProps as m, PropertyRowVariant as n, PropertySpanProps as p, SelectRowProps as q, SliderRowProps as s, TextRowProps as t, ToggleRowProps as v };

package/dist/_dts/shapeKinds-Cx_rxwsa.d.ts

@@ -0,0 +1,87 @@
+/**
+ * The kit's built-in shape kinds — one table, every other spelling derived.
+ *
+ * Lives in `core/` rather than beside the shape tools because both layers ask
+ * questions of the same set: the interactions layer decides whether
+ * `insertAction` can paint a live preview for a kind, and the canvas layer
+ * decides which shape tools `useBuiltinShapeTools` mounts and what
+ * `BUNDLE_TOOLS` / `defaultNodeRouting` / `defaultNodeProperties` enumerate.
+ *
+ * This module imports nothing on purpose: `useBuiltinShapeTools` imports the
+ * package barrel, so anything barrel-reachable that needs these lists at
+ * module-evaluation time must not route through it.
+ */
+/** What the kit knows about one built-in shape kind. */
+interface ShapeKindDescriptor {
+    /** Mounted as a built-in shape tool by `useBuiltinShapeTools`, and so a
+     *  member of `BuiltinShapeToolId` / `KIT_SHAPE_KINDS`. `image` is false:
+     *  `useImageTool` needs a `src` and can't be auto-mounted. */
+    readonly tool: boolean;
+    /** `insertAction` emits an `insertPreview` overlay for this kind, and the
+     *  dispatcher overlay layer knows how to draw it. Kinds without one still
+     *  commit; they just have no live drag preview (`pen` and `lasso` don't
+     *  route through `insertAction` at all). */
+    readonly insertPreview: boolean;
+}
+/**
+ * Declaration order is the enumeration order of every derived list —
+ * `KIT_SHAPE_KINDS`, and through it `defaultNodeRouting` /
+ * `defaultNodeProperties` / `BUNDLE_TOOLS.exhaustive`.
+ */
+declare const SHAPE_KINDS: {
+    readonly rect: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly ellipse: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly line: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly polygon: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly star: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly pen: {
+        readonly tool: true;
+        readonly insertPreview: false;
+    };
+    readonly pencil: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly lasso: {
+        readonly tool: true;
+        readonly insertPreview: false;
+    };
+    readonly text: {
+        readonly tool: true;
+        readonly insertPreview: true;
+    };
+    readonly image: {
+        readonly tool: false;
+        readonly insertPreview: true;
+    };
+};
+/** The keys of a shape-kind table whose descriptor sets `F` to `true`. */
+type ShapeKindsWhere<T, F extends keyof ShapeKindDescriptor> = {
+    [K in keyof T]: T[K] extends Record<F, true> ? K : never;
+}[keyof T];
+/**
+ * Built-in shape tool ids handled by `useBuiltinShapeTools`. Each maps to a
+ * kit tool hook + a default `create` that produces a leaf node compatible
+ * with `PATH_PAINTER`.
+ */
+type BuiltinShapeToolId = ShapeKindsWhere<typeof SHAPE_KINDS, 'tool'>;
+/** The insert kinds the kit's dispatcher overlay layer knows how to render.
+ *  Consumer-defined kinds fall outside it: no live preview, commit unaffected. */
+type KitInsertShape = ShapeKindsWhere<typeof SHAPE_KINDS, 'insertPreview'>;
+
+export type { BuiltinShapeToolId as B, KitInsertShape as K };