@asymmetric-effort/specifyjs 0.2.97 → 0.2.100

package/dist/types/components/layout/desktop-background/src/DesktopBackground.d.ts

@@ -0,0 +1,23 @@
+import type { ContextMenuItem } from '../../../overlay/context-menu/src/index';
+export interface DesktopBackgroundProps {
+    /** Background color. Default: '#2c001e' (Ubuntu aubergine) */
+    backgroundColor?: string;
+    /** Background gradient. Overrides backgroundColor if provided. */
+    backgroundGradient?: string;
+    /** Background image URL. Rendered with cover/center. */
+    backgroundImage?: string;
+    /** Background image opacity (0-1). Default: 1. */
+    backgroundImageOpacity?: number;
+    /** Context menu items shown on right-click of the background. */
+    contextMenuItems?: ContextMenuItem[];
+    /** Called when the background itself is clicked (not a child). */
+    onClick?: () => void;
+    /** Called when the background is double-clicked. */
+    onDoubleClick?: () => void;
+    /** Overflow behavior for the background container. Default: 'visible'.
+     *  Use 'hidden' to clip children at the container bounds. */
+    overflow?: 'hidden' | 'visible' | 'auto';
+    /** Content rendered on top of the background. */
+    children?: unknown;
+}
+export declare function DesktopBackground(props: DesktopBackgroundProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/layout/desktop-background/src/index.d.ts

@@ -0,0 +1,2 @@
+export { DesktopBackground } from './DesktopBackground';
+export type { DesktopBackgroundProps } from './DesktopBackground';

package/dist/types/components/layout/draggable-window/src/DraggableWindow.d.ts

@@ -0,0 +1,59 @@
+export interface DraggableWindowProps {
+    /** Unique window identifier */
+    id: string;
+    /** Window title displayed in the title bar */
+    title: string;
+    /** Optional icon (URL or emoji) displayed left of the title */
+    icon?: string;
+    /** Initial position relative to the containing element (pixels) */
+    defaultPosition?: {
+        x: number;
+        y: number;
+    };
+    /** Initial size (pixels) */
+    defaultSize?: {
+        width: number;
+        height: number;
+    };
+    /** Minimum size constraints (pixels). Default: { width: 200, height: 150 } */
+    minSize?: {
+        width: number;
+        height: number;
+    };
+    /** Maximum size constraints (pixels). Default: unconstrained */
+    maxSize?: {
+        width: number;
+        height: number;
+    };
+    /** Whether the window can be resized. Default: true */
+    resizable?: boolean;
+    /** Whether the window can be dragged. Default: true */
+    draggable?: boolean;
+    /** Current window state */
+    windowState?: 'normal' | 'maximized' | 'minimized';
+    /** Whether the window is currently focused (determines title bar styling) */
+    focused?: boolean;
+    /** Z-index for stacking order */
+    zIndex?: number;
+    /** Called when the user clicks the close button */
+    onClose?: () => void;
+    /** Called when the user clicks the minimize button */
+    onMinimize?: () => void;
+    /** Called when the user clicks the maximize/restore button */
+    onMaximize?: () => void;
+    /** Called when the window is clicked (for focus management) */
+    onFocus?: () => void;
+    /** Called when the window is moved. Reports final position. */
+    onMove?: (position: {
+        x: number;
+        y: number;
+    }) => void;
+    /** Called when the window is resized. Reports final size. */
+    onResize?: (size: {
+        width: number;
+        height: number;
+    }) => void;
+    /** Application content rendered inside the window body */
+    children?: unknown;
+}
+export declare function DraggableWindow(props: DraggableWindowProps): unknown;

package/dist/types/components/layout/draggable-window/src/index.d.ts

@@ -0,0 +1,2 @@
+export { DraggableWindow } from './DraggableWindow';
+export type { DraggableWindowProps } from './DraggableWindow';

package/dist/types/components/layout/flex-container/src/FlexContainer.d.ts

@@ -0,0 +1,42 @@
+export interface FlexContainerProps {
+    /** flex-direction (default: 'row') */
+    direction?: 'row' | 'row-reverse' | 'column' | 'column-reverse';
+    /** flex-wrap (default: 'nowrap') */
+    wrap?: 'nowrap' | 'wrap' | 'wrap-reverse';
+    /** Gap between items (CSS value) */
+    gap?: string;
+    /** CSS align-items */
+    alignItems?: string;
+    /** CSS justify-content */
+    justifyContent?: string;
+    /** Use inline-flex instead of flex */
+    inline?: boolean;
+    /** Extra inline styles */
+    style?: Record<string, string>;
+    /** Extra class name */
+    className?: string;
+    /** Children */
+    children?: unknown;
+}
+export interface FlexItemProps {
+    /** Shorthand flex property (e.g. '1 1 auto') */
+    flex?: string;
+    /** flex-grow */
+    grow?: number;
+    /** flex-shrink */
+    shrink?: number;
+    /** flex-basis */
+    basis?: string;
+    /** align-self override */
+    alignSelf?: string;
+    /** order */
+    order?: number;
+    /** Extra inline styles */
+    style?: Record<string, string>;
+    /** Extra class name */
+    className?: string;
+    /** Children */
+    children?: unknown;
+}
+export declare function FlexContainer(props: FlexContainerProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;
+export declare function FlexItem(props: FlexItemProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/layout/flex-container/src/index.d.ts

@@ -0,0 +1,2 @@
+export { FlexContainer, FlexItem } from './FlexContainer';
+export type { FlexContainerProps, FlexItemProps } from './FlexContainer';

package/dist/types/components/layout/footer/src/Footer.d.ts

@@ -0,0 +1,25 @@
+export interface FooterProps {
+    /** Content for the left section */
+    left?: unknown;
+    /** Content for the center section */
+    center?: unknown;
+    /** Content for the right section */
+    right?: unknown;
+    /** Border top style */
+    borderTop?: string;
+    /** Background color */
+    background?: string;
+    /** Text color */
+    color?: string;
+    /** Font size */
+    fontSize?: string;
+    /** Padding */
+    padding?: string;
+    /** Max width for inner container */
+    maxWidth?: string;
+    /** CSS className */
+    className?: string;
+    /** ARIA label for the footer landmark */
+    ariaLabel?: string;
+}
+export declare function Footer(props: FooterProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/layout/footer/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Footer } from './Footer';
+export type { FooterProps } from './Footer';

package/dist/types/components/layout/grid/src/Grid.d.ts

@@ -0,0 +1,54 @@
+export interface GridBreakpoint {
+    /** Min-width media query value (e.g. '768px') */
+    minWidth: string;
+    /** Column template override at this breakpoint */
+    columns?: number | string;
+    /** Row template override */
+    rows?: string;
+    /** Gap override */
+    gap?: string;
+}
+export interface GridProps {
+    /** Number of equal columns or a CSS grid-template-columns string */
+    columns?: number | string;
+    /** CSS grid-template-rows value */
+    rows?: string;
+    /** Gap between grid cells (CSS value, e.g. '16px' or '1rem 2rem') */
+    gap?: string;
+    /** CSS align-items for the grid container */
+    alignItems?: string;
+    /** CSS justify-items for the grid container */
+    justifyItems?: string;
+    /** When set, uses auto-fit with minmax(minColWidth, 1fr) */
+    minColWidth?: string;
+    /** Named grid areas (grid-template-areas lines) */
+    areas?: string[];
+    /** Responsive breakpoints — rendered as inline style overrides via CSS custom properties */
+    responsive?: GridBreakpoint[];
+    /** Extra inline styles */
+    style?: Record<string, string>;
+    /** Extra class name */
+    className?: string;
+    /** Children */
+    children?: unknown;
+}
+export interface GridItemProps {
+    /** grid-column value (e.g. 'span 2', '1 / 3') */
+    gridColumn?: string;
+    /** grid-row value */
+    gridRow?: string;
+    /** grid-area name */
+    gridArea?: string;
+    /** CSS align-self */
+    alignSelf?: string;
+    /** CSS justify-self */
+    justifySelf?: string;
+    /** Extra inline styles */
+    style?: Record<string, string>;
+    /** Extra class name */
+    className?: string;
+    /** Children */
+    children?: unknown;
+}
+export declare function Grid(props: GridProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;
+export declare function GridItem(props: GridItemProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/layout/grid/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Grid, GridItem } from './Grid';
+export type { GridProps, GridItemProps, GridBreakpoint } from './Grid';

package/dist/types/components/layout/panel/src/Panel.d.ts

@@ -0,0 +1,23 @@
+export interface PanelProps {
+    /** Panel title */
+    title?: string;
+    /** Whether the panel can be collapsed (default: false) */
+    collapsible?: boolean;
+    /** Initial collapsed state when collapsible (default: false) */
+    defaultCollapsed?: boolean;
+    /** Icon element rendered before the title */
+    icon?: unknown;
+    /** Slot rendered at the trailing edge of the header */
+    headerRight?: unknown;
+    /** Show border (default: true) */
+    bordered?: boolean;
+    /** Shadow: 'none' | 'sm' | 'md' (default: 'none') */
+    shadow?: 'none' | 'sm' | 'md';
+    /** Extra inline styles */
+    style?: Record<string, string>;
+    /** Extra class name */
+    className?: string;
+    /** Body content */
+    children?: unknown;
+}
+export declare function Panel(props: PanelProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/layout/panel/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Panel } from './Panel';
+export type { PanelProps } from './Panel';

package/dist/types/components/layout/scroll-container/src/ScrollContainer.d.ts

@@ -0,0 +1,21 @@
+export interface ScrollContainerProps {
+    /** Maximum height (CSS value) */
+    maxHeight?: string;
+    /** Maximum width (CSS value) */
+    maxWidth?: string;
+    /** Scroll direction (default: 'vertical') */
+    direction?: 'vertical' | 'horizontal' | 'both';
+    /** Scrollbar visibility (default: 'auto') */
+    showScrollbar?: 'auto' | 'always' | 'hover' | 'never';
+    /** Inner padding (CSS value) */
+    padding?: string;
+    /** Show inset shadow at scroll edges to hint overflow (default: false) */
+    shadow?: boolean;
+    /** Extra inline styles */
+    style?: Record<string, string>;
+    /** Extra class name */
+    className?: string;
+    /** Children */
+    children?: unknown;
+}
+export declare function ScrollContainer(props: ScrollContainerProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/layout/scroll-container/src/index.d.ts

@@ -0,0 +1,2 @@
+export { ScrollContainer } from './ScrollContainer';
+export type { ScrollContainerProps } from './ScrollContainer';

package/dist/types/components/layout/splitter/src/Splitter.d.ts

@@ -0,0 +1,19 @@
+export interface SplitterProps {
+    /** Split direction (default: 'horizontal' — left|right panes) */
+    direction?: 'horizontal' | 'vertical';
+    /** Initial split percentage for the first pane (default: 50) */
+    initialSplit?: number;
+    /** Minimum size of either pane in px (default: 50) */
+    minSize?: number;
+    /** Maximum size of the first pane in px */
+    maxSize?: number;
+    /** Divider bar width/height in px (default: 6) */
+    dividerSize?: number;
+    /** Extra inline styles for the container */
+    style?: Record<string, string>;
+    /** Extra class name */
+    className?: string;
+    /** Exactly two children */
+    children?: unknown[];
+}
+export declare function Splitter(props: SplitterProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/layout/splitter/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Splitter } from './Splitter';
+export type { SplitterProps } from './Splitter';

package/dist/types/components/layout/tabs/src/Tabs.d.ts

@@ -0,0 +1,29 @@
+export interface TabDefinition {
+    /** Unique tab identifier */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Optional icon element */
+    icon?: unknown;
+    /** Disabled state */
+    disabled?: boolean;
+    /** Tab panel content */
+    content: unknown;
+}
+export interface TabsProps {
+    /** Tab definitions */
+    tabs: TabDefinition[];
+    /** Controlled active tab id */
+    activeTab?: string;
+    /** Change handler (receives tab id) */
+    onChange?: (tabId: string) => void;
+    /** Tab list position (default: 'top') */
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    /** Visual variant (default: 'line') */
+    variant?: 'line' | 'card' | 'pill';
+    /** Extra inline styles */
+    style?: Record<string, string>;
+    /** Extra class name */
+    className?: string;
+}
+export declare function Tabs(props: TabsProps): import("specifyjs/shared/types").SpecElement<import("specifyjs/shared/types").Props>;

package/dist/types/components/layout/tabs/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Tabs } from './Tabs';
+export type { TabsProps, TabDefinition } from './Tabs';

package/dist/types/components/layout/window-manager/src/WindowManager.d.ts

@@ -0,0 +1,106 @@
+import type { SpecNode } from '../../../../core/src/shared/types';
+export interface WindowState {
+    /** Unique window identifier */
+    id: string;
+    /** Window title */
+    title: string;
+    /** Optional icon */
+    icon?: string;
+    /** Current position (pixels relative to workspace) */
+    position: {
+        x: number;
+        y: number;
+    };
+    /** Current size (pixels) */
+    size: {
+        width: number;
+        height: number;
+    };
+    /** Window display state */
+    windowState: 'normal' | 'maximized' | 'minimized';
+    /** Z-index for stacking order */
+    zIndex: number;
+    /** Whether this window is currently focused */
+    focused: boolean;
+    /** Application-specific props passed to the window content */
+    appProps?: Record<string, unknown>;
+}
+export interface WindowManagerContextValue {
+    /** All currently tracked windows */
+    windows: WindowState[];
+    /** Open a new window or focus it if already open */
+    openWindow(config: {
+        id: string;
+        title: string;
+        icon?: string;
+        position?: {
+            x: number;
+            y: number;
+        };
+        size?: {
+            width: number;
+            height: number;
+        };
+        appProps?: Record<string, unknown>;
+    }): void;
+    /** Close and remove a window */
+    closeWindow(id: string): void;
+    /** Raise a window to the top and set it as focused */
+    focusWindow(id: string): void;
+    /** Minimize a window */
+    minimizeWindow(id: string): void;
+    /** Maximize a window to fill the workspace */
+    maximizeWindow(id: string): void;
+    /** Restore a window from maximized or minimized to normal */
+    restoreWindow(id: string): void;
+    /** Update a window's position */
+    moveWindow(id: string, position: {
+        x: number;
+        y: number;
+    }): void;
+    /** Update a window's size */
+    resizeWindow(id: string, size: {
+        width: number;
+        height: number;
+    }): void;
+    /** Tile all open, non-minimized windows in a grid */
+    tileWindows(): void;
+    /** Cascade all open, non-minimized windows with offset stacking */
+    cascadeWindows(): void;
+    /** Minimize all windows */
+    minimizeAll(): void;
+    /** Currently focused window ID, or null */
+    focusedWindowId: string | null;
+}
+export interface WindowManagerProps {
+    /** Workspace bounds */
+    workspaceBounds?: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    /** Default size for new windows. Default: { width: 600, height: 400 } */
+    defaultWindowSize?: {
+        width: number;
+        height: number;
+    };
+    /** Position offset for cascading new windows. Default: { x: 30, y: 30 } */
+    cascadeOffset?: {
+        x: number;
+        y: number;
+    };
+    /** Called when any window is opened */
+    onWindowOpen?: (id: string) => void;
+    /** Called when any window is closed */
+    onWindowClose?: (id: string) => void;
+    /** Called when focus changes */
+    onFocusChange?: (id: string | null) => void;
+    /** Children */
+    children?: unknown;
+}
+export declare function WindowManagerProvider(props: WindowManagerProps): SpecNode;
+/**
+ * Access the WindowManager context from any descendant component.
+ */
+export declare function useWindowManager(): WindowManagerContextValue;

package/dist/types/components/layout/window-manager/src/index.d.ts

@@ -0,0 +1,2 @@
+export { WindowManagerProvider, useWindowManager } from './WindowManager';
+export type { WindowState, WindowManagerContextValue, WindowManagerProps } from './WindowManager';

package/dist/types/components/math/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './vec';
+export * from './mat';
+export * from './mat4';
+export * from './quaternion';
+export * from './solver';

package/dist/types/components/math/src/mat.d.ts

@@ -0,0 +1,71 @@
+/** NxN matrix stored as a flat row-major Float64Array. */
+export interface MatN {
+    readonly data: Float64Array;
+    readonly size: number;
+}
+/**
+ * Create a zero-initialized NxN matrix.
+ * @param size - The number of rows (and columns).
+ */
+export declare function matN(size: number): MatN;
+/**
+ * Create an NxN identity matrix.
+ * @param size - The number of rows (and columns).
+ */
+export declare function matNIdentity(size: number): MatN;
+/**
+ * Get the value at (row, col) in a MatN.
+ * @param m - The matrix.
+ * @param row - Row index (zero-based).
+ * @param col - Column index (zero-based).
+ */
+export declare function matNGet(m: MatN, row: number, col: number): number;
+/**
+ * Return a new MatN with the value at (row, col) set to val.
+ * @param m - The source matrix.
+ * @param row - Row index (zero-based).
+ * @param col - Column index (zero-based).
+ * @param val - The value to set.
+ */
+export declare function matNSet(m: MatN, row: number, col: number, val: number): MatN;
+/**
+ * Multiply two NxN matrices. Both must have the same size.
+ * @param a - Left matrix.
+ * @param b - Right matrix.
+ */
+export declare function matNMultiply(a: MatN, b: MatN): MatN;
+/**
+ * Multiply an NxN matrix by an N-length column vector.
+ * @param m - The matrix.
+ * @param v - The vector as a Float64Array of length N.
+ * @returns A new Float64Array of length N.
+ */
+export declare function matNMultiplyVec(m: MatN, v: Float64Array): Float64Array;
+/**
+ * Transpose an NxN matrix.
+ * @param m - The matrix to transpose.
+ */
+export declare function matNTranspose(m: MatN): MatN;
+/**
+ * Scale every element of a matrix by a scalar.
+ * @param m - The matrix.
+ * @param s - The scalar.
+ */
+export declare function matNScale(m: MatN, s: number): MatN;
+/**
+ * Add two NxN matrices element-wise. Both must have the same size.
+ * @param a - First matrix.
+ * @param b - Second matrix.
+ */
+export declare function matNAdd(a: MatN, b: MatN): MatN;
+/**
+ * Create a deep copy of a MatN.
+ * @param m - The matrix to copy.
+ */
+export declare function matNCopy(m: MatN): MatN;
+/**
+ * Create an NxN matrix from a flat array of numbers (row-major order).
+ * @param size - The number of rows (and columns).
+ * @param values - Flat array of size*size numbers.
+ */
+export declare function matNFromArray(size: number, values: number[]): MatN;

package/dist/types/components/math/src/mat4.d.ts

@@ -0,0 +1,101 @@
+import type { Vec3 } from './vec';
+import type { Quaternion } from './quaternion';
+/**
+ * A 4x4 matrix stored as a Float64Array of 16 elements in column-major order
+ * (OpenGL convention).
+ *
+ * Index layout (column-major):
+ *   [0]  [4]  [8]  [12]
+ *   [1]  [5]  [9]  [13]
+ *   [2]  [6]  [10] [14]
+ *   [3]  [7]  [11] [15]
+ */
+export type Mat4 = Float64Array;
+/** Create a new 4x4 identity matrix. */
+export declare function mat4Identity(): Mat4;
+/**
+ * Multiply two 4x4 matrices: result = a * b.
+ * Both matrices are in column-major order.
+ */
+export declare function mat4Multiply(a: Mat4, b: Mat4): Mat4;
+/** Transpose a 4x4 matrix. */
+export declare function mat4Transpose(m: Mat4): Mat4;
+/**
+ * Compute the inverse of a 4x4 matrix.
+ * Returns null if the matrix is singular (determinant is zero).
+ */
+export declare function mat4Inverse(m: Mat4): Mat4 | null;
+/**
+ * Apply a translation to a 4x4 matrix: result = m * T(v).
+ * @param m - The matrix to translate.
+ * @param v - The translation vector.
+ */
+export declare function mat4Translate(m: Mat4, v: Vec3): Mat4;
+/**
+ * Apply a scale to a 4x4 matrix: result = m * S(v).
+ * @param m - The matrix to scale.
+ * @param v - The scale factors for each axis.
+ */
+export declare function mat4Scale(m: Mat4, v: Vec3): Mat4;
+/**
+ * Rotate a 4x4 matrix around the X axis: result = m * Rx(radians).
+ * @param m - The matrix to rotate.
+ * @param radians - The rotation angle in radians.
+ */
+export declare function mat4RotateX(m: Mat4, radians: number): Mat4;
+/**
+ * Rotate a 4x4 matrix around the Y axis: result = m * Ry(radians).
+ * @param m - The matrix to rotate.
+ * @param radians - The rotation angle in radians.
+ */
+export declare function mat4RotateY(m: Mat4, radians: number): Mat4;
+/**
+ * Rotate a 4x4 matrix around the Z axis: result = m * Rz(radians).
+ * @param m - The matrix to rotate.
+ * @param radians - The rotation angle in radians.
+ */
+export declare function mat4RotateZ(m: Mat4, radians: number): Mat4;
+/**
+ * Create a perspective projection matrix.
+ * @param fovY - Vertical field of view in radians.
+ * @param aspect - Aspect ratio (width / height).
+ * @param near - Distance to the near clipping plane.
+ * @param far - Distance to the far clipping plane.
+ */
+export declare function mat4Perspective(fovY: number, aspect: number, near: number, far: number): Mat4;
+/**
+ * Create an orthographic projection matrix.
+ * @param left - Left clipping plane.
+ * @param right - Right clipping plane.
+ * @param bottom - Bottom clipping plane.
+ * @param top - Top clipping plane.
+ * @param near - Near clipping plane.
+ * @param far - Far clipping plane.
+ */
+export declare function mat4Orthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4;
+/**
+ * Create a view matrix that looks from eye toward target.
+ * @param eye - The camera position.
+ * @param target - The point the camera is looking at.
+ * @param up - The world up vector.
+ */
+export declare function mat4LookAt(eye: Vec3, target: Vec3, up: Vec3): Mat4;
+/**
+ * Create a 4x4 rotation matrix from a unit quaternion.
+ * @param q - The quaternion (should be normalized).
+ */
+export declare function mat4FromQuaternion(q: Quaternion): Mat4;
+/**
+ * Transform a 3D point by a 4x4 matrix (applies translation).
+ * Treats the point as a vec4 with w=1 and performs perspective division.
+ * @param m - The transformation matrix.
+ * @param v - The point to transform.
+ */
+export declare function mat4TransformVec3(m: Mat4, v: Vec3): Vec3;
+/**
+ * Transform a direction vector by a 4x4 matrix (ignores translation).
+ * Treats the vector as a vec4 with w=0.
+ * @param m - The transformation matrix.
+ * @param v - The direction vector to transform.
+ */
+export declare function mat4TransformDirection(m: Mat4, v: Vec3): Vec3;