@declarion/react 0.44.0 → 0.47.0

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

@@ -170,7 +170,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/anchor.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The anchor expression, TypeScript side.
+ *
+ * One grammar for "a moment relative to now", shared with the server
+ * (golang/internal/engine/anchor.go + duration.go). The language boundary is
+ * the only reason there are two implementations; nothing else may declare a
+ * third.
+ *
+ *   now            the current instant
+ *   now+3w         three weeks ahead
+ *   now-1d         one day back
+ *   now+3w-1d      the offsets compose, left to right
+ *
+ * Units are Go's plus `d` (24h) and `w` (7d). Calendar units `y` and `mo` are
+ * refused: they have no fixed length, so `1mo` from the 31st has no answer this
+ * platform is willing to invent.
+ */
+/**
+ * One magnitude, and the running total of an anchor's offsets, may not exceed
+ * 100 years. Beyond that the server's arithmetic saturates and `now+N` and
+ * `now-N` collapse to the same instant - a predicate written to match nothing
+ * matching everything. The client refuses the same inputs so a template that
+ * would fail on the server does not silently produce a different moment here.
+ */
+export declare const MAX_DURATION_MAGNITUDE_MS: number;
+/** At most this many signed offsets in one anchor expression. */
+export declare const MAX_ANCHOR_OFFSETS = 8;
+/** Parse one unsigned magnitude (`3w`, `1h30m`). Returns null when invalid. */
+export declare function parseDurationMagnitudeMs(text: string): number | null;
+/**
+ * Parse an anchor expression WITHOUT any surface wrapper - `now`, `now+3w`,
+ * `now+3w-1d` - and return the summed offset in milliseconds. Returns null when
+ * the text is not a valid anchor expression, which the caller surfaces the way
+ * it surfaces any unresolved token: by leaving the template visible rather than
+ * writing a wrong moment.
+ */
+export declare function parseAnchorOffsetMs(expr: string): number | null;

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/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/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;