@declarion/react 0.45.0 → 0.48.0

package/dist-lib/lib/actions.d.ts

@@ -96,11 +96,19 @@ export declare function actionNeedsConfirm(action: Action | undefined): boolean;
  * Precedence: disabled-reason > description > name.
  *
  * A labeled control already shows the name, so its tooltip is the description
- * alone; an icon-only control (`display.icon_only`) has no visible label, so it
- * shows "name - description" to keep the name reachable on hover. Absent
- * description falls back to the name - byte-identical to pre-description behavior.
+ * alone. A control with no visible label - declared `display.icon_only`, or a
+ * label the bar dropped to keep the button in a tight row - leads with the NAME
+ * on its own line, then the description. Absent description falls back to the
+ * name.
  */
-export declare function actionTooltip(action: Action | undefined, name: string, isDisabled: boolean, reason: string | null | undefined): string;
+export declare function actionTooltip(action: Action | undefined, name: string, isDisabled: boolean, reason: string | null | undefined, 
+/**
+ * True when the button is rendering WITHOUT its label right now - either
+ * because the author declared `display.icon_only`, or because the row ran out
+ * of width and the bar dropped the label to keep the button. Both cases leave
+ * the user looking at an icon, so the tooltip has to say the name first.
+ */
+labelHidden?: boolean): string;
 /**
  * Builds the full dot-qualified action code for API calls.
  */
@@ -170,7 +178,7 @@ export type ResolvedActionLayoutNode = ResolvedActionLeaf | ResolvedActionGroup;
  * @param rowSelection  All selected rows for bulk context (list_toolbar bulk mode).
  *                      Pass empty array for non-bulk contexts.
  */
-export declare function applyRowState(layout: ResolvedActionLayoutNode[], entityActions: Record<string, Action> | undefined, globalActions: Record<string, Action> | undefined, row: Record<string, unknown>, rowSelection: Record<string, unknown>[]): ResolvedActionLayoutNode[];
+export declare function applyRowState(layout: ResolvedActionLayoutNode[], entityActions: Record<string, Action> | undefined, globalActions: Record<string, Action> | undefined, row: Record<string, unknown>, rowSelection: Record<string, unknown>[], allowedActionCodes?: ReadonlySet<string>): ResolvedActionLayoutNode[];
 /**
  * Composes a flat ResolvedActionLayoutNode[] from an entity's actions map,
  * filtered to those that include the given slot in their visibility array,

package/dist-lib/lib/filter-evaluator.d.ts

@@ -0,0 +1,16 @@
+import type { FilterNode } from "./filters";
+/** Metadata needed to evaluate a record-only filter condition. */
+export interface FilterRecordField {
+    type: "string" | "text" | "rich_text" | "email" | "url" | "phone" | "enum" | "int" | "float" | "decimal" | "date" | "timestamp" | "time" | "bool" | "ref" | "uuid" | (string & {});
+}
+export type FilterRecordFields = Readonly<Record<string, FilterRecordField>>;
+export type FilterRecord = Readonly<Record<string, unknown>>;
+/**
+ * Evaluate a loader-validated filter tree against one already-loaded record.
+ *
+ * This deliberately accepts only the deterministic record subset: it has no
+ * caller, clock, relation lookup, or value coercion input. A missing field is
+ * the same as null for `is_empty`; every other operator returns false for a
+ * missing, null, or empty value.
+ */
+export declare function evaluateFilterTree(nodes: FilterNode[], fields: FilterRecordFields, record: FilterRecord): boolean;

package/dist-lib/lib/filters.d.ts

@@ -4,8 +4,8 @@ export interface FilterNode {
     field?: string;
     op?: FilterOp;
     value?: unknown;
-    /** OR group: each inner array is AND-ed, groups are OR-ed */
-    or?: FilterNode[][];
+    /** OR group: child nodes are OR-ed. */
+    or?: FilterNode[];
     /** Explicit AND group (rarely needed, top-level is implicit AND) */
     and?: FilterNode[];
 }
@@ -39,7 +39,13 @@ export declare const NO_VALUE_OPS: Set<FilterOp>;
 export declare const MULTI_VALUE_OPS: Set<FilterOp>;
 /** Human-friendly display names for operators. */
 export declare const OP_LABELS: Record<FilterOp, string>;
+export interface FilterURLState {
+    filters: FilterNode[];
+    error: string | null;
+}
 /** Parse filters from URL search params (JSON `filters` param). */
+export declare function parseFilterURLState(searchParams: URLSearchParams): FilterURLState;
+/** Parse the final tree and reject malformed URL state instead of treating it as no filter. */
 export declare function parseFiltersFromURL(searchParams: URLSearchParams): FilterNode[];
 /** Write filters to URL search params. */
 export declare function setFiltersInURL(filters: FilterNode[], searchParams: URLSearchParams): void;
@@ -48,7 +54,7 @@ export declare function setFiltersInURL(filters: FilterNode[], searchParams: URL
  * Uses the JSON `filters` param for the API request.
  */
 export declare function filtersToApiParams(filters: FilterNode[]): URLSearchParams;
-/** Check if the filter tree has any OR groups (needs Level 2 UI). */
+/** Check if the filter tree has any OR groups. */
 export declare function hasOrGroups(nodes: FilterNode[]): boolean;
 /** Extract flat field conditions from a FilterNode array (ignoring OR/AND structure). */
 export declare function flatFieldConditions(nodes: FilterNode[]): FilterNode[];
@@ -67,5 +73,5 @@ export declare function countActiveFilters(nodes: FilterNode[]): number;
 export declare function formatFilterChip(node: FilterNode, resolveValue?: FilterValueResolver): string;
 /** Create a simple equality filter node. */
 export declare function eqFilter(field: string, value: string): FilterNode;
-/** Remove a filter node by field name, recursing into OR/AND groups. */
+/** Remove a filter node by field name, recursing through the final tree. */
 export declare function removeFilter(nodes: FilterNode[], field: string): FilterNode[];

package/dist-lib/lib/longPressGesture.d.ts

@@ -0,0 +1,55 @@
+/**
+ * How long a press is held before it becomes a Row Menu request. 500ms is what
+ * Android and iOS both use for their own long-press, so a user's thumb already
+ * knows this number.
+ */
+export declare const LONG_PRESS_HOLD_MS = 500;
+/**
+ * How far the pointer may drift and still be a press. Past this the gesture is a
+ * scroll, and a list that opens menus while the user is scrolling it is worse
+ * than one with no long-press at all.
+ */
+export declare const LONG_PRESS_MOVE_TOLERANCE_PX = 10;
+/** Where a press started. `null` means no press is in progress. */
+export type PressOrigin = {
+    x: number;
+    y: number;
+} | null;
+export type LongPressInput = {
+    type: "down";
+    x: number;
+    y: number;
+}
+/** Pointer moved, or the surface under it scrolled. */
+ | {
+    type: "move";
+    x: number;
+    y: number;
+}
+/** Released, cancelled by the OS, or the element lost the pointer. */
+ | {
+    type: "release";
+}
+/** The hold timer elapsed. */
+ | {
+    type: "held";
+};
+export type LongPressOutcome = 
+/** A press is in progress; keep the timer running. */
+"pending"
+/** No press is in progress; cancel any timer. */
+ | "idle"
+/** Open the Row Menu at the press origin. */
+ | "fire";
+export interface LongPressStep {
+    origin: PressOrigin;
+    outcome: LongPressOutcome;
+}
+/**
+ * Advances the gesture. Returns the new origin and what the caller should do.
+ *
+ * A `held` without an origin cannot fire: the timer is cleared on every exit,
+ * but a timer that has already been queued when the press ends would otherwise
+ * open a menu after the user let go.
+ */
+export declare function stepLongPress(origin: PressOrigin, input: LongPressInput, tolerance?: number): LongPressStep;

package/dist-lib/lib/messages.d.ts

@@ -1,5 +1,6 @@
 import { type LocalizedString } from "../types/schema";
 import type { PublicParam } from "../types/api";
+export declare const DEFAULT_LOCALE = "en";
 export type MessageCatalog = Record<string, LocalizedString> | undefined;
 export declare function localizedMessage(messages: MessageCatalog, code: string, locale: string, fallback?: string): string;
 export declare function publicLocale(parameters: PublicParam[] | undefined): string;

package/dist-lib/lib/page-inset.d.ts

@@ -0,0 +1,3 @@
+import type { CSSProperties } from "react";
+/** Horizontal padding for a page shell, notch-aware. `base` is the design inset in px. */
+export declare function pageInsetX(base: number): Pick<CSSProperties, "paddingLeft" | "paddingRight">;

package/dist-lib/lib/variants.d.ts

@@ -0,0 +1,7 @@
+import { type FilterRecord } from "./filter-evaluator";
+import type { Entity, Screen } from "../types/schema";
+export declare function resolveEntityVariantCode(entity: Entity, record: FilterRecord): string | undefined;
+export declare function variantActionCodesForRecord(entity: Entity | undefined, record: FilterRecord): ReadonlySet<string> | undefined;
+export declare function commonVariantActionCodes(entity: Entity | undefined, records: readonly FilterRecord[]): ReadonlySet<string> | undefined;
+export declare function resolveScreenVariantCode(entity: Entity, screen: Screen, record: FilterRecord): string | undefined;
+export declare function effectiveScreenForRecord(entity: Entity | undefined, screen: Screen | undefined, record: FilterRecord): Screen | undefined;

package/dist-lib/lib/viewport-category.d.ts

@@ -0,0 +1,44 @@
+export type ViewportCategory = "phone" | "tablet" | "desktop";
+export interface ResponsiveBreakpoints {
+    phoneMax: number;
+    tabletMax: number;
+    /**
+     * The height at or below which a viewport no wider than `tabletMax` is a
+     * phone held sideways. Required, never optional: a missing bound would
+     * silently restore the width-only rule, which is the defect it exists to
+     * remove.
+     */
+    landscapePhoneMaxHeight: number;
+}
+export interface ResponsiveViewport {
+    width: number;
+    height: number;
+    touch?: boolean;
+}
+export interface ResponsiveMode {
+    category: ViewportCategory;
+    width: number;
+    height: number;
+    isPhone: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    touch: boolean;
+}
+export declare const DEFAULT_RESPONSIVE_BREAKPOINTS: ResponsiveBreakpoints;
+/**
+ * The device class, from BOTH viewport axes.
+ *
+ * A phone is a device, not a width. Read from width alone, the same phone is a
+ * phone upright and a tablet on its side - so rotating it swapped cards for a
+ * table, sections for tabs, and the compact header for the desktop one, all at
+ * once. The second clause is that device: no wider than a tablet AND short.
+ *
+ * Height is admitted only UNDER the tablet width ceiling, because a wide short
+ * window (a 1600x480 browser, a wide embed strip) is a desktop, and a height
+ * clause without the ceiling would reclassify it.
+ */
+export declare function resolveViewportCategory(viewport: {
+    width: number;
+    height: number;
+    touch?: boolean;
+}, breakpoints?: ResponsiveBreakpoints): ViewportCategory;