@golemui/core 0.0.2 → 0.12.0

package/lib/store/reducers/set-meta.d.ts

@@ -0,0 +1,3 @@
+import { State } from '../model';
+import * as Actions from '../actions';
+export declare const setMeta: (state: State, action: Actions.SET_META) => State;

package/lib/store/reducers/utils.d.ts

@@ -1,4 +1,3 @@
-import { DotPath } from '../../shared';
 import { State } from '../model';
 /**
  * Conditionally applies a reducer function based on a predicate
@@ -26,7 +25,6 @@ import { State } from '../model';
  * ```
  */
 export declare const reduceIf: (predicate: (state: State) => boolean, reducerFn: (state: State) => State) => (state: State) => State;
-export declare const isControlTouched: (widgetPath: DotPath) => (state: State) => boolean;
 export declare const hasWhen: (val: unknown) => val is {
     when: string;
 };

package/lib/store/reducers/validate-all.d.ts

@@ -1,3 +1,4 @@
 import { ValidatorFn } from '../../form-validator';
+import { I18nTranslator } from '../../i18n';
 import { State } from '../model';
-export declare const validateAll: (validators: ValidatorFn<any>) => (state: State) => State;
+export declare const validateAll: (validators: ValidatorFn<any>, localization: I18nTranslator) => (state: State) => State;

package/lib/store/selectors.d.ts

@@ -5,7 +5,11 @@ import { State } from './model';
 export declare const dataByPath$: <T = any>(path: DotPath) => import('rxjs').UnaryFunction<Observable<State>, Observable<T>>;
 export declare const validationByPath$: (path: DotPath) => import('rxjs').UnaryFunction<Observable<State>, Observable<import('../shared').ValidationStatus>>;
 export declare const injectedValidationByPath$: (path: DotPath) => import('rxjs').UnaryFunction<Observable<State>, Observable<import('../shared').ValidationStatus>>;
-export declare const calculatedWidgetsByUid$: (uid: Uid) => import('rxjs').UnaryFunction<Observable<State>, Observable<import('../form-widget').NonFunctionWidget<string, any, any>>>;
+/**
+ * Emits the current calculated widget for the given uid
+ * Re triggers on widget changes OR store.lang changes
+ */
+export declare const calculatedWidgetsByUid$: (uid: Uid) => (state$: Observable<State>) => Observable<import('../form-widget').NonFunctionWidget<string, any, any>>;
 export declare const calculatedLayoutChildrenByUid$: (uid: Uid) => import('rxjs').UnaryFunction<Observable<State>, Observable<(import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, (import('../form-widget').DisplayWidget<never, any, any> | import('../form-widget').InputWidget<any, never, any, any, any> | LayoutWidget<never, any, any, /*elided*/ any> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]> | import('../form-widget').ActionWidget<never, any, any> | import('../form-widget').FunctionWidget<never, any, any>)[]>>;
 export declare const selectWidgetFlags: import('rxjs').UnaryFunction<Observable<State>, Observable<Record<string, {
     hidden?: boolean;

package/lib/utils/array.d.ts

@@ -30,6 +30,66 @@ export declare const SKIP: unique symbol;
  * ```
  */
 export declare function filterMap<T, U>(array: readonly T[], fn: (value: T, index: number, array: readonly T[]) => U | typeof SKIP): U[];
+/**
+ * Iterates over an array, executing a callback function only for elements
+ * that satisfy the provided predicate.
+ *
+ * This combines `filter` and `forEach` in a single pass without allocating
+ * intermediate arrays, improving performance and reducing garbage collection.
+ *
+ * @typeParam T - The type of the input array elements.
+ * @typeParam S - A narrower type of the elements that pass a type guard predicate.
+ *
+ * @param array - The source array to iterate over.
+ * @param predicate - A function that evaluates each element. If it returns truthy,
+ * the callback is executed.
+ * @param callback - A function to execute for each element that passes the predicate.
+ *
+ * @example
+ * ```ts
+ * filterTap(
+ *   [1, 2, 3, 4],
+ *   n => n % 2 === 0,
+ *   n => console.log('Even:', n)
+ * );
+ * // "Even: 2", "Even: 4"
+ * ```
+ */
+export declare function filterTap<T, S extends T>(array: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => value is S, callback: (value: S, index: number, array: readonly T[]) => void): void;
+export declare function filterTap<T>(array: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => unknown, callback: (value: T, index: number, array: readonly T[]) => void): void;
+/**
+ * Iterates over an array, filtering elements using a predicate, and
+ * accumulating a single result using a reducer function.
+ *
+ * This combines `filter` and `reduce` in a single pass without allocating
+ * intermediate arrays, improving performance and memory efficiency.
+ *
+ * @typeParam T - The type of the input array elements.
+ * @typeParam S - A narrower type of the elements that pass a type guard predicate.
+ * @typeParam U - The type of the accumulated value.
+ *
+ * @param array - The source array to iterate over.
+ * @param predicate - A function that evaluates each element. If truthy, the element
+ * is passed to the reducer.
+ * @param reducer - A function that accumulates the results.
+ * @param initialValue - The initial value to start the accumulation. Required to ensure
+ * safety in cases where no elements pass the predicate.
+ *
+ * @returns The final accumulated value.
+ *
+ * @example
+ * ```ts
+ * const sumOfEvens = filterReduce(
+ *   [1, 2, 3, 4, 5],
+ *   n => n % 2 === 0,
+ *   (acc, n) => acc + n,
+ *   0
+ * );
+ * // sumOfEvens: 6
+ * ```
+ */
+export declare function filterReduce<T, S extends T, U>(array: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => value is S, reducer: (accumulator: U, currentValue: S, index: number, array: readonly T[]) => U, initialValue: U): U;
+export declare function filterReduce<T, U>(array: readonly T[], predicate: (value: T, index: number, array: readonly T[]) => unknown, reducer: (accumulator: U, currentValue: T, index: number, array: readonly T[]) => U, initialValue: U): U;
 /**
  * Compares two arrays for structural equality by applying a predicate
  * to each pair of elements.

package/lib/utils/assert-no-prop-collisions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Throws when properties in widget.props collide with base widget props, which should never happen.
+ * Only runs when dev mode is enabled via enableDevMode().
+ *
+ * @param widgetUid to describe which field has collisions
+ * @param props widget.props
+ * @param base widget props
+ */
+export declare function assertNoPropCollisions(widgetUid: string, props: Record<string, unknown> | undefined, base: Record<string, unknown>): void;

package/lib/utils/dev-mode.d.ts

@@ -0,0 +1,2 @@
+export declare function enableDevMode(): void;
+export declare function isDevMode(): boolean;

package/lib/utils/form.d.ts

@@ -1,4 +1,55 @@
+import { $Errors, DotPath } from '../shared';
+import { State } from '../store/model';
 import * as Widget from '../form-widget';
+/**
+ * Expression Scopes define the root namespaces accessible within
+ * reactive expressions and template strings.
+ */
+export declare const EXPRESSION_SCOPE: {
+    readonly FORM: "$form";
+    readonly META: "$meta";
+    readonly ERRORS: "$errors";
+    readonly FORM_IS_INVALID: "$formIsInvalid";
+};
+/**
+ * Heuristically checks if a value looks like a scoped path
+ * rather than a standard string.
+ * To be considered a "potential" scoped path, the value must:
+ * 1. Be a string.
+ * 2. Start with one of the allowed prefixes ($form.*, $meta.*, etc..).
+ * 3. Not contain any spaces (distinguishing it from sentences).
+ *
+ * * @example
+ * isPotentialScopedPath('$form.user.id');  // true
+ * isPotentialScopedPath('name');           // false (No prefix)
+ * isPotentialScopedPath('my file');        // false (Contains space)
+ * isPotentialScopedPath(123);              // false (Not a string)
+ */
+export declare const isPotentialScopedPath: (path: unknown) => path is DotPath;
+export interface ScopedPathResolvers {
+    resolveFormPath: (expr: string) => any;
+    resolveMetaPath: (expr: string) => any;
+    resolveErrorsPath: (expr: string) => any;
+    resolveFormIsInvalid: () => string | boolean;
+}
+/**
+ * Resolves all scoped path placeholders within a string in a single pass.
+ * e.g. "User {{ $form.name }} has status {{ $meta.status }} or {{ $formIsInvalid }}"
+ *
+ * @param input - The template string to process
+ * @param resolvers - Implementation of value resolution logic
+ * @returns The string with all valid placeholders replaced by their resolved values
+ */
+export declare const resolveScopedPaths: (input: string, resolvers: ScopedPathResolvers) => string;
+/**
+ * Resolves a scoped path to its underlying value using the
+ * appropriate resolver based on the path prefix (`$form.*`, `$meta.*`, `$errors.*` or `$formIsInvalid`).
+ *
+ * @param variable - A dot-notation path starting with `$form.`, `$meta.` or `$errors.`, or `$formIsInvalid`.
+ * @param resolvers.resolveFormPath - Resolves a path within the $form scope
+ * @param resolvers.resolveMetaPath - Resolves a path within the $meta scope
+ */
+export declare const resolveScopedPath: (variable: string, resolvers: ScopedPathResolvers) => any;
 /**
  * Flattens the hierarchical form structure into a single-level array of form widgets.
  *
@@ -18,3 +69,11 @@ import * as Widget from '../form-widget';
  * ```
  */
 export declare function flattenForm(widgets: Widget.FormWidget[]): Widget.FormWidget[];
+/**
+ * Calculates validation variables to be used in reactive expressions
+ * e.g. `{ invalidAge: '!!$errors.age' }` or { disabled { when: '$formIsInvalid' } }
+ */
+export declare function calculateValidationVariables(state: State): {
+    $formIsInvalid: boolean;
+    $errors: $Errors;
+};

package/lib/utils/justin.d.ts

@@ -0,0 +1,3 @@
+import { $Errors, ReactiveExpression } from '../shared';
+import { State } from '../store/model';
+export declare function expressionIsTrue(expression: ReactiveExpression, $form: State['data'], $meta: State['meta'], $errors: $Errors, $formIsInvalid: boolean): boolean;

package/lib/utils/object.d.ts

@@ -135,6 +135,8 @@ export declare const set: (object: Record<string, any>, path: DotPath, value: an
  */
 export declare const deleteKey: (object: Record<string, any>, key: string) => Record<string, any>;
 /**
- * Cheap JSON.stringify-based clone object utility
+ * Deep-clones plain objects and arrays while preserving function references
+ * (and other non-plain values) by reference. Functions are stateless widget
+ * resolvers and only need to survive the trip into repeater item configs.
  */
-export declare function cloneObject(obj: Record<string, any>): any;
+export declare function cloneObject<T>(value: T): T;

package/lib/utils/repeater.d.ts

@@ -1,2 +1,32 @@
 import { NonFunctionWidget } from '../form-widget';
-export declare function makeRepeaterItemConfig(widget: NonFunctionWidget<string>, repeaterIndex: number): NonFunctionWidget<string>;
+import { Uid } from '../shared';
+/**
+ * Derives a concrete widget config for a specific repeater item by stamping
+ * the provided indexes into the widget's `uid` (and `path` for input widgets).
+ *
+ * @param widget - The base widget config defined on the repeater template.
+ * @param repeaterIndexes - Ordered list of indexes for each nesting level,
+ *   e.g. `[2, 0]` for the first item of a nested repeater inside the third
+ *   item of an outer repeater.
+ * @returns A new widget config with the indexes baked in; the original is not mutated.
+ *
+ * @example
+ * makeRepeaterItemConfig(widget, [1]) // { uid: 'user-name[1]', path: 'users.1.name' }
+ */
+export declare function makeRepeaterItemConfig(widget: NonFunctionWidget<string>, repeaterIndexes: number[]): NonFunctionWidget<string>;
+export declare function toRepeaterItemUid(uid: Uid, repeaterIndexes: number[]): Uid;
+/**
+ * Replaces `.items.` and `.items?.` tokens in a `when` expression with the
+ * concrete repeater indexes so the expression can be evaluated.
+ * Multiple `items` tokens are replaced in order, supporting nested repeaters.
+ *
+ * @example
+ * // repeaterIndexes = [2]
+ * // "$form.reptr.items.active" -> "$form.reptr.2.active"
+ * // "$form.reptr.items?.active" -> "$form.reptr.2?.active"
+ *
+ * @example
+ * // repeaterIndexes = [1, 0]
+ * // "$form.reptr.teams.items?.devs?.items?.firstName?.length > 0" -> "$form.reptr.teams.1?.devs?.0?.firstName?.length > 0"
+ */
+export declare function transformRepeaterItemWhenExpression(expression: string, repeaterIndexes: number[]): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@golemui/core",
-  "version": "0.0.2",
+  "version": "0.12.0",
   "type": "module",
   "main": "./index.umd.cjs",
   "module": "./index.js",
@@ -26,5 +26,10 @@
     "subscript": "^10.1.8",
     "rxjs": "^7.8.0",
     "@standard-schema/spec": "^1.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/golemui/golemui.git",
+    "directory": "libs/core"
   }
 }