@agnos-ui/core 0.0.1-alpha.3 → 0.0.1-alpha.5

package/utils/internal/traversal.js

@@ -0,0 +1,105 @@
+const removeSymbol = Symbol('remove');
+function _traversal(key, value, fn, index) {
+    const transformedValue = fn(key, value, { removeSymbol, index });
+    const type = Object.prototype.toString.call(transformedValue);
+    switch (type) {
+        case '[object Object]': {
+            const newJson = {};
+            const baseKey = key ? key + '.' : '';
+            for (const [name, objectValue] of Object.entries(transformedValue)) {
+                const newValue = _traversal(baseKey + name, objectValue, fn);
+                if (newValue !== removeSymbol) {
+                    newJson[name] = newValue;
+                }
+            }
+            return newJson;
+        }
+        case '[object Map]': {
+            const oldMap = transformedValue;
+            const newMap = new Map();
+            const baseKey = key ? key + '.' : '';
+            for (const [mapKey, objectValue] of Object.entries(oldMap)) {
+                const newValue = _traversal(baseKey + name, objectValue, fn);
+                if (newValue !== removeSymbol) {
+                    newMap.set(mapKey, newValue);
+                }
+            }
+            return newMap;
+        }
+        case '[object Array]': {
+            const ar = transformedValue;
+            const newArray = [];
+            const baseKey = (key ? key : '') + '[]';
+            for (let i = 0; i < ar.length; i++) {
+                const newValue = _traversal(baseKey, ar[i], fn, i);
+                if (newValue !== removeSymbol) {
+                    newArray.push(newValue);
+                }
+            }
+            return newArray;
+        }
+        case '[object Set]': {
+            const oldSet = transformedValue;
+            const newSet = new Set();
+            const baseKey = (key ? key : '') + '[]';
+            const ar = [...oldSet];
+            for (let i = 0; i < ar.length; i++) {
+                const newValue = _traversal(baseKey, ar[i], fn, i);
+                if (newValue !== removeSymbol) {
+                    newSet.add(newValue);
+                }
+            }
+            return newSet;
+        }
+        default:
+            break;
+    }
+    return transformedValue;
+}
+/**
+ * Creates a JSON walker function that can be used to traverse and transform
+ * the properties of a JSON object.
+ *
+ * @param fn - The callback function called for each property in the JSON object.
+ * @returns A function that takes a JSON object as input and applies the provided
+ * callback function to each property.
+ *
+ * @example
+ * ```typescript
+ * const json = {
+ *   name: 'John',
+ *   age: 30,
+ *   address: {
+ *     city: 'New York',
+ *     country: 'USA',
+ *   },
+ *   useless: '',
+ * };
+ *
+ * const transform = createTraversal((key, value, {removeSymbol}) => {
+ *   if (key === 'age') {
+ *     return value * 2; // Double the age
+ *   }
+ *   if (key === 'useless') {
+ * 	   return removeSymbol;
+ *   }
+ *   return value;
+ * });
+ *
+ * const transformedJson = transform(json);
+ * ```
+ */
+export function createTraversal(fn) {
+    return (json) => _traversal('', json, fn);
+}
+/**
+ * Utility method to create a promise with resolve
+ * @returns a promise with resolve
+ */
+export const promiseWithResolve = () => {
+    let resolve;
+    const promise = new Promise((r) => {
+        resolve = r;
+    });
+    return { promise, resolve: resolve };
+};

package/{services → utils}/stores.d.ts

@@ -1,16 +1,11 @@
-import type { ReadableSignal, StoreInput, StoreOptions, StoresInputValues, WritableSignal } from '@amadeus-it-group/tansu';
+import type { ReadableSignal, StoreInput, StoresInputValues, WritableSignal } from '@amadeus-it-group/tansu';
+import type { ConfigValidator, PropsConfig, ValuesOrReadableSignals, WritableWithDefaultOptions } from '../types';
 export type ToWritableSignal<P> = {
     [K in keyof P as `${K & string}$`]-?: WritableSignal<P[K], P[K] | undefined>;
 };
 export type ReadableSignals<T extends object> = {
     [K in keyof T]?: ReadableSignal<T[K] | undefined>;
 };
-export type ValuesOrReadableSignals<T extends object> = {
-    [K in keyof T]?: ReadableSignal<T[K] | undefined> | T[K];
-};
-export type ValuesOrWritableSignals<T extends object> = {
-    [K in keyof T]?: WritableSignal<T[K] | undefined> | T[K];
-};
 export type WithoutDollar<S extends `${string}$`> = S extends `${infer U}$` ? U : never;
 export type ValueOfStore<S extends ReadableSignal<any>> = S extends ReadableSignal<infer U> ? U : never;
 export type ToState<S extends {
@@ -51,18 +46,6 @@ export declare function createPatch<T extends object>(stores: ToWritableSignal<T
  * @returns the object with changed properties
  */
 export declare function findChangedProperties<T extends Record<string, any>>(obj1: Partial<T>, obj2: Partial<T>): Partial<T> | null;
-export declare const INVALID_VALUE: unique symbol;
-export type NormalizeValue<T> = (value: T) => T | typeof INVALID_VALUE;
-export interface WritableWithDefaultOptions<T> {
-    /**
-     * the normalize value function. should return the invalidValue symbol when the provided value is invalid
-     */
-    normalizeValue?: NormalizeValue<T>;
-    /**
-     * the equal function, allowing to compare two values. used to check if a previous and current values are equals.
-     */
-    equal?: StoreOptions<T>['equal'];
-}
 /**
  * Returns a writable store whose value is either its own value (when it is not undefined) or a default value
  * that comes either from the `config$` store (when it is not undefined) or from `defValue`.
@@ -78,9 +61,6 @@ export interface WritableWithDefaultOptions<T> {
  * @returns a writable store with the extra default value and normalization logic described above
  */
 export declare function writableWithDefault<T>(defValue: T, config$?: ReadableSignal<T | undefined>, options?: WritableWithDefaultOptions<T>, own$?: WritableSignal<T | undefined>): WritableSignal<T, T | undefined>;
-export type ConfigValidator<T extends object> = {
-    [K in keyof T]?: WritableWithDefaultOptions<T[K]>;
-};
 /**
  * Returns true if the provided argument is a store (ReadableSignal).
  * @param x - argument that is tested
@@ -156,22 +136,18 @@ export declare const writablesWithDefault: <T extends object>(defConfig: T, prop
  * ```
  */
 export declare const writablesForProps: <T extends object>(defConfig: T, propsConfig?: PropsConfig<T> | undefined, options?: { [K in keyof T]?: WritableWithDefaultOptions<T[K]> | undefined; } | undefined) => [ToWritableSignal<T>, <U extends Partial<T>>(storesValues?: void | U | undefined) => void];
-export interface PropsConfig<U extends object> {
-    /**
-     * Object containing, for each property, either its initial value, or a store that will contain the value at any time.
-     * When the value of a property is undefined or invalid, the value from the config is used.
-     */
-    props?: ValuesOrWritableSignals<U>;
-    /**
-     * Either a store of objects containing, for each property, the default value,
-     * or an object containing, for each property, either a store containing the default value or the default value itself.
-     */
-    config?: ReadableSignal<Partial<U>> | ValuesOrReadableSignals<Partial<U>>;
-}
 export declare const stateStores: <A extends {
     [x: `${string}$`]: ReadableSignal<any>;
 }>(inputStores: A) => {
     state$: ReadableSignal<ToState<A>>;
     stores: { [key in `${string}$` & keyof A]: ReadableSignal<ValueOfStore<A[key]>>; };
 };
-export declare const bindableDerived: <T, U extends [WritableSignal<T, T>, ...StoreInput<any>[]]>(onChange$: ReadableSignal<(value: T) => void>, stores: U, adjustValue: (arg: StoresInputValues<U>) => T, equal?: (currentValue: T, newValue: T) => boolean) => ReadableSignal<T>;
+/**
+ * Creates a computed store that binds to multiple stores and triggers a callback when the value changes.
+ * @param onChange$ - A readable signal callback function to execute when the value changes.
+ * @param stores - An array of Svelte stores, with the main store at index 0.
+ * @param adjustValue - A function to adjust the value of the main store. By default, the value of the main store is returned.
+ * @param equal - A function to determine if two values are equal. Used to compare the ajusted value with the current one.
+ * @returns The derived store that reflects the combined state of the input stores.
+ */
+export declare const bindableDerived: <T, U extends [WritableSignal<T, T>, ...StoreInput<any>[]]>(onChange$: ReadableSignal<(value: T) => void>, stores: U, adjustValue?: (arg: StoresInputValues<U>) => T, equal?: (currentValue: T, newValue: T) => boolean) => ReadableSignal<T>;

package/{services → utils}/stores.js

@@ -1,5 +1,6 @@
-import { asReadable, batch, computed, derived, get, readable, writable } from '@amadeus-it-group/tansu';
-import { identity } from '../utils';
+import { asReadable, asWritable, batch, computed, derived, get, readable, writable } from '@amadeus-it-group/tansu';
+import { INVALID_VALUE } from '../types';
+import { identity } from './internal/func';
 /**
  *
  * Utility function designed to create a `patch` function related to the provided stores.
@@ -56,10 +57,6 @@ export function findChangedProperties(obj1, obj2) {
     }
     return hasUpdate ? changedValues : null;
 }
-const update = function (updater) {
-    this.set(updater(this()));
-};
-export const INVALID_VALUE = Symbol();
 /**
  * Returns a writable store whose value is either its own value (when it is not undefined) or a default value
  * that comes either from the `config$` store (when it is not undefined) or from `defValue`.
@@ -90,19 +87,16 @@ export function writableWithDefault(defValue, config$ = readable(undefined), opt
     };
     const validatedDefConfig$ = computed(() => callNormalizeValue(config$()), { equal });
     const validatedOwnValue$ = computed(() => callNormalizeValue(own$(), validatedDefConfig$), { equal });
-    return asReadable(validatedOwnValue$, {
-        set(value) {
-            if (value !== undefined) {
-                const normalizedValue = normalizeValue(value);
-                if (normalizedValue === INVALID_VALUE) {
-                    console.error('Not setting invalid value', value);
-                    return;
-                }
-                value = normalizedValue;
+    return asWritable(validatedOwnValue$, (value) => {
+        if (value !== undefined) {
+            const normalizedValue = normalizeValue(value);
+            if (normalizedValue === INVALID_VALUE) {
+                console.error('Not setting invalid value', value);
+                return;
             }
-            own$.set(value);
-        },
-        update,
+            value = normalizedValue;
+        }
+        own$.set(value);
     });
 }
 /**
@@ -236,7 +230,15 @@ export const stateStores = (inputStores) => {
         }),
     };
 };
-export const bindableDerived = (onChange$, stores, adjustValue, equal = (currentValue, newValue) => newValue === currentValue) => {
+/**
+ * Creates a computed store that binds to multiple stores and triggers a callback when the value changes.
+ * @param onChange$ - A readable signal callback function to execute when the value changes.
+ * @param stores - An array of Svelte stores, with the main store at index 0.
+ * @param adjustValue - A function to adjust the value of the main store. By default, the value of the main store is returned.
+ * @param equal - A function to determine if two values are equal. Used to compare the ajusted value with the current one.
+ * @returns The derived store that reflects the combined state of the input stores.
+ */
+export const bindableDerived = (onChange$, stores, adjustValue = (arg) => arg[0], equal = (currentValue, newValue) => newValue === currentValue) => {
     let currentValue = stores[0]();
     return derived(stores, {
         derive(values) {

package/utils/writables.d.ts

@@ -0,0 +1,26 @@
+import type { WritableWithDefaultOptions } from '../types';
+import { INVALID_VALUE } from '../types';
+export declare const testToNormalizeValue: <T>(filter: (value: any) => value is T) => (value: any) => typeof INVALID_VALUE | T;
+export declare const typeNumber: WritableWithDefaultOptions<number>;
+export interface TypeNumberInRangeOptions {
+    /** If `true`, the range checking will be strict, excluding the minimum and maximum values. Default is `false`. */
+    strict?: boolean;
+    /** If `true`, values outside the range will be clamped to the minimum or maximum. Default is `true`. */
+    useClamp?: boolean;
+}
+/**
+ * Factory function for creating a type constraint for numbers within a specified range.
+ *
+ * @param min - The minimum value.
+ * @param max - The maximum value.
+ * @param options - Additional options to customize the behavior.
+ *
+ * @returns A type guard function that returns the clamp value or INVALID_VALUE depending on the provided options.
+ */
+export declare function typeNumberInRangeFactory(min: number, max: number, options?: TypeNumberInRangeOptions): WritableWithDefaultOptions<number>;
+export declare const typeBoolean: WritableWithDefaultOptions<boolean>;
+export declare const typeBooleanOrNull: WritableWithDefaultOptions<boolean | null>;
+export declare const typeString: WritableWithDefaultOptions<string>;
+export declare const typeFunction: WritableWithDefaultOptions<(...args: any[]) => any>;
+export declare const typeHTMLElementOrNull: WritableWithDefaultOptions<HTMLElement | null>;
+export declare const typeArray: WritableWithDefaultOptions<any[]>;

package/utils/writables.js

@@ -0,0 +1,66 @@
+import { allowNull, clamp, isArray, isBoolean, isFunction, isHTMLElement, isNumber, isString } from './internal/checks';
+import { INVALID_VALUE } from '../types';
+export const testToNormalizeValue = (filter) => (value) => filter(value) ? value : INVALID_VALUE;
+const numberNormalizeFn = testToNormalizeValue(isNumber);
+export const typeNumber = {
+    normalizeValue: numberNormalizeFn,
+};
+/**
+ * Factory function for creating a type constraint for numbers within a specified range.
+ *
+ * @param min - The minimum value.
+ * @param max - The maximum value.
+ * @param options - Additional options to customize the behavior.
+ *
+ * @returns A type guard function that returns the clamp value or INVALID_VALUE depending on the provided options.
+ */
+export function typeNumberInRangeFactory(min, max, options = {}) {
+    const { strict = false, useClamp = true } = options;
+    return {
+        normalizeValue: (value) => {
+            let normalizedNumber = numberNormalizeFn(value);
+            if (normalizedNumber !== INVALID_VALUE) {
+                if (!strict && useClamp) {
+                    normalizedNumber = clamp(normalizedNumber, max, min);
+                }
+                if (normalizedNumber >= min && normalizedNumber <= max) {
+                    if (!strict || (normalizedNumber !== min && normalizedNumber !== max)) {
+                        return normalizedNumber;
+                    }
+                }
+            }
+            return INVALID_VALUE;
+        },
+    };
+}
+export const typeBoolean = {
+    normalizeValue: testToNormalizeValue(isBoolean),
+};
+export const typeBooleanOrNull = {
+    normalizeValue: testToNormalizeValue(allowNull(isBoolean)),
+};
+export const typeString = {
+    normalizeValue: testToNormalizeValue(isString),
+};
+export const typeFunction = {
+    normalizeValue: testToNormalizeValue(isFunction),
+    equal: Object.is,
+};
+export const typeHTMLElementOrNull = {
+    normalizeValue: testToNormalizeValue(allowNull(isHTMLElement)),
+    equal: Object.is,
+};
+export const typeArray = {
+    normalizeValue: testToNormalizeValue(isArray),
+    equal: (a, b) => {
+        if (a === b) {
+            return true;
+        }
+        else {
+            if (a?.length !== b?.length) {
+                return false;
+            }
+            return a.every((val, index) => val === b[index]);
+        }
+    },
+};

package/extendWidget.d.ts

@@ -1,3 +0,0 @@
-import type { ConfigValidator } from './services/stores';
-import type { Widget, WidgetFactory, WidgetProps, WidgetState } from './types';
-export declare const extendWidgetProps: <W extends Widget<object, object, object, object, object>, ExtraProps extends object>(factory: WidgetFactory<W>, extraPropsDefaults: ExtraProps, extraPropsConfig?: ConfigValidator<ExtraProps> | undefined) => WidgetFactory<Widget<WidgetProps<W> & ExtraProps, WidgetState<W> & ExtraProps, W["api"], W["actions"], W["directives"]>>;

package/select.d.ts

@@ -1,196 +0,0 @@
-import type { HasFocus } from './services/focustrack';
-import type { PropsConfig } from './services/stores';
-import type { Widget } from './types';
-import type { WidgetsCommonPropsAndState } from './commonProps';
-export interface SelectCommonPropsAndState<Item> extends WidgetsCommonPropsAndState {
-    /**
-     * List of selected items
-     */
-    selected: Item[];
-    /**
-     * Filtered text to be display in the filter input
-     */
-    filterText: string;
-    /**
-     * true if the select is disabled
-     */
-    disabled: boolean;
-    /**
-     * true if the select is open
-     */
-    opened: boolean;
-    /**
-     * true if a loading process is being done
-     */
-    loading: boolean;
-}
-export interface SelectProps<T> extends SelectCommonPropsAndState<T> {
-    /**
-     * List of available items for the dropdown
-     */
-    items: T[];
-    /**
-     * Custom function to filter an item.
-     * By default, item is considered as a string, and the function returns true if the text is found
-     */
-    matchFn(item: T, text: string): boolean;
-    /**
-     * Custom function to get the id of an item
-     * By default, the item is returned
-     */
-    itemId(item: T): string;
-    /**
-     * Callback called when the text filter change
-     * @param text - Filtered text
-     */
-    onFilterTextChange?(text: string): void;
-}
-/**
- * Item representation built from the items provided in parameters
- */
-export interface ItemCtx<T> {
-    /**
-     * Original item given in the parameters
-     */
-    item: T;
-    /**
-     * Unique id to identify the item
-     */
-    id: string;
-    /**
-     * Specify if the item is checked
-     */
-    selected: boolean;
-    /**
-     * Select the item
-     */
-    select(): void;
-    /**
-     * Unselect the item
-     */
-    unselect(): void;
-    /**
-     * Toggle the item selection
-     */
-    toggle(): void;
-}
-export interface SelectState<Item> extends SelectCommonPropsAndState<Item> {
-    /**
-     * List of visible items displayed in the menu
-     */
-    visible: ItemCtx<Item>[];
-    /**
-     * Highlighted item context.
-     * It is designed to define the highlighted item in the dropdown menu
-     */
-    highlighted: ItemCtx<Item> | undefined;
-}
-export interface SelectApi<Item> {
-    /**
-     * Clear all the selected items
-     */
-    clear(): void;
-    /**
-     * Clear the filter text
-     */
-    clearText(): void;
-    /**
-     * Highlight the given item, if there is a corresponding match among the visible list
-     */
-    highlight(item: Item): void;
-    /**
-     * Highlight the first item among the visible list
-     */
-    highlightFirst(): void;
-    /**
-     * Highlight the previous item among the visible list
-     * Loop to the last item if needed
-     */
-    highlightPrevious(): void;
-    /**
-     * Highlight the next item among the visible list.
-     * Loop to the first item if needed
-     */
-    highlightNext(): void;
-    /**
-     * Highlight the last item among the visible list
-     */
-    highlightLast(): void;
-    /**
-     * Focus the provided item among the selected list.
-     * The focus feature is designed to know what item must be focused in the UI, i.e. among the badge elements.
-     */
-    focus(item: Item): void;
-    /**
-     * Focus the first element
-     */
-    focusFirst(): void;
-    /**
-     * Focus the previous element. If no element was focused before the call, nothing happens.
-     */
-    focusPrevious(): void;
-    /**
-     * Focus the next element. If no element was focused before the call, nothing happens.
-     */
-    focusNext(): void;
-    /**
-     * Focus the last element. If no element was focused before the call, nothing happens.
-     */
-    focusLast(): void;
-    /**
-     * Select the provided item.
-     * The selected list is used to
-     * @param item - the item to select
-     */
-    select(item: Item): void;
-    /**
-     * Unselect the provided item.
-     * @param item - the item to unselect
-     */
-    unselect(item: Item): void;
-    /**
-     * Toggle the selection of an item
-     * @param item - the item to toggle
-     * @param selected - an optional boolean to enforce the selected/unselected state instead of toggling
-     */
-    toggleItem(item: Item, selected?: boolean): void;
-    /**
-     * open the select
-     */
-    open(): void;
-    /**
-     * close the select
-     */
-    close(): void;
-    /**
-     * Toggle the dropdown menu
-     * @param isOpen - If specified, set the menu in the defined state.
-     */
-    toggle(isOpen?: boolean): void;
-}
-export interface SelectDirectives {
-    /**
-     * Directive to be used in the input group and the menu containers
-     */
-    hasFocusDirective: HasFocus['directive'];
-}
-export interface SelectActions {
-    /**
-     * Method to be plugged to on the 'input' event. The input text will be used as the filter text.
-     */
-    onInput: (e: {
-        target: any;
-    }) => void;
-    /**
-     * Method to be plugged to on an keydown event, in order to control the keyboard interactions with the highlighted item.
-     * It manages arrow keys to move the highlighted item, or enter to toggle the item.
-     */
-    onInputKeydown: (e: any) => void;
-}
-export type SelectWidget<Item> = Widget<SelectProps<Item>, SelectState<Item>, SelectApi<Item>, SelectActions, SelectDirectives>;
-/**
- * Create a SelectWidget with given config props
- * @param config - an optional alert config
- * @returns a SelectWidget
- */
-export declare function createSelect<Item>(config?: PropsConfig<SelectProps<Item>>): SelectWidget<Item>;