@design-factory/angular 21.0.4 → 21.1.0-next.0

package/node_modules/@agnos-ui/core/utils/internal/promise.d.ts

@@ -0,0 +1,98 @@
+import type { ReadableSignal } from '@amadeus-it-group/tansu';
+/**
+ * Represents the result of a promise that is still pending.
+ */
+export interface PromisePendingResult {
+    /** Pending status */
+    status: 'pending';
+}
+/**
+ * A constant representing a pending promise result.
+ */
+export declare const promisePending: PromisePendingResult;
+/**
+ * Represents the state of a promise, which can be either fulfilled, rejected, or pending.
+ *
+ * @template T - The type of the value promised
+ */
+export type PromiseState<T> = PromiseFulfilledResult<T> | PromiseRejectedResult | PromisePendingResult;
+/**
+ * Create a readable promise state store from a promise.
+ *
+ * The state of the returned store tracks the state of the promise and the resolved value or rejection reason.
+ *
+ * @param value - the promise
+ * @returns the readable promise state store
+ */
+export declare const promiseStateStore: <T>(value: T) => ReadableSignal<Readonly<PromiseState<Awaited<T>>>>;
+/**
+ * Create a readable promise state store from a promise store.
+ *
+ * @param promiseStore$ - the promise store
+ * @returns the readable promise state store
+ */
+export declare const promiseStoreToPromiseStateStore: <T>(promiseStore$: ReadableSignal<T>) => ReadableSignal<PromiseState<Awaited<T>>>;
+/**
+ * Create a value store from a promise state store
+ *
+ * The returned value store is only updated if the promise is fulfilled.
+ *
+ * @param store$ - the promise state store
+ * @param initialValue - the initial value of the returned value store
+ * @param equal - an equal function to compare values
+ * @returns the value store
+ */
+export declare const promiseStateStoreToValueStore: <T>(store$: ReadableSignal<PromiseState<T>>, initialValue: T, equal?: (a: T, b: T) => boolean) => ReadableSignal<T>;
+/**
+ * Create a value store from a promise store
+ *
+ * The returned value store is only updated if the promise is fulfilled.
+ *
+ * @param promiseStore$ - the promise store
+ * @param initialValue - the initial value of the returned value store
+ * @param equal - an equal function to compare values
+ * @returns the value store
+ */
+export declare const promiseStoreToValueStore: <T>(promiseStore$: ReadableSignal<T>, initialValue: Awaited<T>, equal?: (a: Awaited<T>, b: Awaited<T>) => boolean) => ReadableSignal<Awaited<T>>;
+/**
+ * Create a promise from a readable store and a fulfilled condition function.
+ *
+ * The promise is fulfilled when the state of the store respects the provided condition function.
+ *
+ * @param store - the readable store
+ * @param condition - the condition function
+ * @returns the promise and an unsubscribe function
+ */
+export declare const promiseFromStore: <T>(store: ReadableSignal<T>, condition?: (value: T) => boolean) => {
+    promise: Promise<T>;
+    unsubscribe(): void;
+};
+/**
+ * Create a promise from an HTML element event.
+ *
+ * @param element - the event target
+ * @param event - the event to listen to
+ * @returns the promise and an unsubscribe function
+ */
+export declare const promiseFromEvent: (element: EventTarget, event: string) => {
+    promise: Promise<Event>;
+    unsubscribe(): void;
+};
+/**
+ * Create a promise that resolves once a timeout has been reached.
+ *
+ * @param delay - the delay in milli seconds
+ * @returns a promise and an unsubscribe function
+ */
+export declare const promiseFromTimeout: (delay: number) => {
+    promise: Promise<void>;
+    unsubscribe(): void;
+};
+/**
+ * Utility method to create a promise with resolve
+ * @returns a promise with resolve
+ */
+export declare const promiseWithResolve: () => {
+    promise: Promise<void>;
+    resolve: (value: void | Promise<void>) => void;
+};

package/node_modules/@agnos-ui/core/utils/internal/scrollbars.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A function to remove the scrollbars on the body element. It can be reverted using the {@link revertScrollbars} function.
+ */
+export declare const removeScrollbars: () => void;
+/**
+ * A function to revert the removal of scrollbars performed by the {@link removeScrollbars} function.
+ */
+export declare const revertScrollbars: () => void;

package/node_modules/@agnos-ui/core/utils/internal/sort.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The default comparision between two values, using the javascript < and > signs.
+ *
+ * @param a - the first input
+ * @param b - the second input
+ * @returns 1, 0 or -1 depending on the default compare
+ */
+export declare const compareDefault: (a: any, b: any) => -1 | 0 | 1;
+/**
+ * A comparision function between DOM elements, based on {@link https://developer.mozilla.org/fr/docs/Web/API/Node/compareDocumentPosition | Node.compareDocumentPosition}.
+ *
+ * @param element1 - the first node
+ * @param element2 - the second node
+ * @returns 1, 0 or -1
+ */
+export declare const compareDomOrder: (element1: Node, element2: Node) => 0 | 1 | -1;

package/node_modules/@agnos-ui/core/utils/internal/ssrHTMLElement.d.ts

@@ -0,0 +1,17 @@
+import type { SSRHTMLElement, StyleKeyCustomProperty, StyleKeyKebabCase, StyleValue } from '../../types';
+/**
+ * A unique symbol used to represent the attributes and style of an SSR (Server-Side Rendering) HTML element.
+ * This symbol can be used as a key for storing or retrieving attributes and styles associated with an SSR HTML element.
+ */
+export declare const ssrHTMLElementAttributesAndStyle: unique symbol;
+/**
+ * Create an SSRHTMLElement
+ * @returns the created SSRHTMLElement
+ */
+export declare const ssrHTMLElement: () => SSRHTMLElement;
+/**
+ * Converts a style object to a CSS text string.
+ * @param style - The style object to convert.
+ * @returns The CSS text string representation of the style object.
+ */
+export declare const cssTextFromObject: (style: Partial<Record<StyleKeyKebabCase | StyleKeyCustomProperty, StyleValue>>) => string;

package/node_modules/@agnos-ui/core/utils/internal/textDirection.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns the text direction of an element, using a call to `getComputedStyle`.
+ *
+ * @param element - the HTML element
+ * @returns the text direction of the element, 'ltr' or 'rtl'
+ */
+export declare const getTextDirection: (element: HTMLElement) => "ltr" | "rtl";

package/node_modules/@agnos-ui/core/utils/internal/traversal.d.ts

@@ -0,0 +1,54 @@
+interface TraversalFnOptions {
+    /**
+     * Remove symbol to return to remove the value
+     */
+    removeSymbol?: symbol;
+    /**
+     * index of the array, when looping on the elements
+     */
+    index?: number;
+}
+type TraversalFn = (key: string, value: any, options: TraversalFnOptions) => any;
+/**
+ * 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 declare function createTraversal(fn: TraversalFn): (json: any) => any;
+/**
+ * Utility method to create a promise with resolve
+ * @returns a promise with resolve
+ */
+export declare const promiseWithResolve: () => {
+    promise: Promise<void>;
+    resolve: (value: void | Promise<void>) => void;
+};
+export {};

package/node_modules/@agnos-ui/core/utils/stores.cjs

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const tansu = require("@amadeus-it-group/tansu");
+const types = require("../types.cjs");
+const utils_func = require("./func.cjs");
+const utils_id = require("./id.cjs");
+function createPatch(stores) {
+  return function(storesValues) {
+    tansu.batch(() => {
+      for (const [name, value] of Object.entries(storesValues)) {
+        stores[`${name}$`]?.set(value);
+      }
+    });
+  };
+}
+function findChangedProperties(obj1, obj2) {
+  if (obj1 === obj2) {
+    return null;
+  }
+  let hasUpdate = false;
+  const changedValues = {};
+  const keys = /* @__PURE__ */ new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
+  for (const key of keys) {
+    const value = obj2[key];
+    if (obj1[key] !== value) {
+      changedValues[key] = value;
+      hasUpdate = true;
+    }
+  }
+  return hasUpdate ? changedValues : null;
+}
+function writableWithDefault(defValue, config$ = tansu.readable(void 0), options = {}, own$ = tansu.writable(void 0)) {
+  const { normalizeValue = utils_func.identity, equal = Object.is } = options;
+  const getDefValue = () => defValue;
+  const callNormalizeValue = (value, defValue2 = getDefValue) => {
+    const normalizedValue = value === void 0 ? void 0 : normalizeValue(value);
+    if (normalizedValue === types.INVALID_VALUE) {
+      console.error("Not using invalid value", value);
+      return defValue2();
+    }
+    if (normalizedValue === void 0) {
+      return defValue2();
+    }
+    return normalizedValue;
+  };
+  const validatedDefConfig$ = tansu.computed(() => callNormalizeValue(config$()), { equal });
+  const validatedOwnValue$ = tansu.computed(() => callNormalizeValue(own$(), validatedDefConfig$), { equal });
+  return tansu.asWritable(validatedOwnValue$, (value) => {
+    if (value !== void 0) {
+      const normalizedValue = normalizeValue(value);
+      if (normalizedValue === types.INVALID_VALUE) {
+        console.error("Not setting invalid value", value);
+        return;
+      }
+      value = normalizedValue;
+    }
+    own$.set(value);
+  });
+}
+const isStore = (x) => !!(x && typeof x === "function" && "subscribe" in x);
+const toReadableStore = (x) => isStore(x) ? x : tansu.readable(x);
+const toWritableStore = (x) => isStore(x) ? x : tansu.writable(x);
+const normalizeConfigStores = (keys, config) => {
+  const res = {};
+  if (config) {
+    const configIsStore = isStore(config);
+    for (const key of keys) {
+      res[key] = configIsStore ? tansu.computed(() => config()[key]) : toReadableStore(config[key]);
+    }
+  }
+  return res;
+};
+const mergeConfigStores = (keys, config1, config2) => {
+  const res = {};
+  for (const key of keys) {
+    const config1Store = config1?.[key];
+    const config2Store = config2?.[key];
+    res[key] = config1Store && config2Store ? tansu.computed(() => config1Store() ?? config2Store()) : config1Store || config2Store;
+  }
+  return res;
+};
+const writablesWithDefault = (defConfig, propsConfig, options) => {
+  const res = {};
+  const keys = Object.keys(defConfig);
+  const configStores = normalizeConfigStores(keys, propsConfig?.config);
+  const props = propsConfig?.props;
+  for (const key of keys) {
+    const propValue = props?.[key];
+    res[`${key}$`] = writableWithDefault(defConfig[key], configStores[key], options?.[key], toWritableStore(propValue));
+  }
+  return res;
+};
+const writablesForProps = (defConfig, propsConfig, options) => {
+  const stores = writablesWithDefault(defConfig, propsConfig, options);
+  return [stores, createPatch(stores)];
+};
+const stateStores = (inputStores) => {
+  const storesNames = [];
+  const storesArray = [];
+  const stores = {};
+  for (const [key, store] of Object.entries(inputStores)) {
+    if (key.endsWith("$")) {
+      storesNames.push(key.substring(0, key.length - 1));
+      storesArray.push(store);
+      stores[key] = tansu.asReadable(store);
+    }
+  }
+  return {
+    stores,
+    state$: tansu.computed(() => {
+      const values = storesArray.map(tansu.get);
+      const res = {};
+      storesNames.forEach((name, index) => {
+        res[name] = values[index];
+      });
+      return res;
+    })
+  };
+};
+const bindableDerived = (onChange$, stores, adjustValue = (arg) => arg[0], equal = (currentValue, newValue) => newValue === currentValue) => {
+  let currentValue = stores[0]();
+  return tansu.asWritable(
+    tansu.derived(stores, {
+      derive(values) {
+        const newValue = adjustValue(values);
+        const rectifiedValue = !equal(values[0], newValue);
+        if (rectifiedValue) {
+          stores[0].set(newValue);
+        }
+        if (rectifiedValue || !equal(currentValue, newValue)) {
+          currentValue = newValue;
+          onChange$()(newValue);
+        }
+        return newValue;
+      },
+      equal
+    }),
+    stores[0].set.bind(stores[0])
+  );
+};
+const bindableProp = (store$, onChange$, adjustValue = utils_func.identity, equal = tansu.equal) => tansu.asWritable(
+  tansu.computed(() => adjustValue(store$()), { equal }),
+  (newValue) => {
+    const adjustedValue = adjustValue(newValue);
+    if (!equal(store$(), adjustedValue)) {
+      store$.set(adjustedValue);
+      onChange$()(adjustedValue);
+    }
+  }
+);
+function idWithDefault(id$) {
+  const autoId$ = tansu.computed(() => utils_id.generateId());
+  return tansu.computed(() => id$() || autoId$());
+}
+const true$ = tansu.readable(true);
+const false$ = tansu.readable(false);
+exports.bindableDerived = bindableDerived;
+exports.bindableProp = bindableProp;
+exports.createPatch = createPatch;
+exports.false$ = false$;
+exports.findChangedProperties = findChangedProperties;
+exports.idWithDefault = idWithDefault;
+exports.isStore = isStore;
+exports.mergeConfigStores = mergeConfigStores;
+exports.normalizeConfigStores = normalizeConfigStores;
+exports.stateStores = stateStores;
+exports.toReadableStore = toReadableStore;
+exports.toWritableStore = toWritableStore;
+exports.true$ = true$;
+exports.writableWithDefault = writableWithDefault;
+exports.writablesForProps = writablesForProps;
+exports.writablesWithDefault = writablesWithDefault;

package/node_modules/@agnos-ui/core/utils/stores.d.ts

@@ -0,0 +1,224 @@
+import type { ReadableSignal, StoreInput, StoresInputValues, WritableSignal } from '@amadeus-it-group/tansu';
+import type { ConfigValidator, PropsConfig, ValuesOrReadableSignals, WritableWithDefaultOptions } from '../types';
+/**
+ * Transforms the properties of a given type `P` into writable signals.
+ * Each property key in `P` is suffixed with a `$` and its type is converted to a `WritableSignal`.
+ * @template P - The original type whose properties are to be transformed.
+ */
+export type ToWritableSignal<P> = {
+    [K in keyof P as `${K & string}$`]-?: WritableSignal<P[K], P[K] | undefined>;
+};
+/**
+ * Represents a collection of readable signals for an object type `T`.
+ * Each key in the object corresponds to a key in `T`, and the value is an optional `ReadableSignal`
+ * that can hold the value of the corresponding property in `T` or `undefined`.
+ *
+ * @template T - The object type for which the readable signals are defined.
+ */
+export type ReadableSignals<T extends object> = {
+    [K in keyof T]?: ReadableSignal<T[K] | undefined>;
+};
+/**
+ * A utility type that removes the trailing dollar sign (`$`) from a string type.
+ *
+ * @template S - A string type that ends with a dollar sign (`$`).
+ * @returns The string type without the trailing dollar sign (`$`), or `never` if the input type does not end with a dollar sign.
+ */
+export type WithoutDollar<S extends `${string}$`> = S extends `${infer U}$` ? U : never;
+/**
+ *
+ * Utility function designed to create a `patch` function related to the provided stores.
+ * Any key given to the patch function which is not in the original object will be ignored.
+ *
+ * @example
+ *
+ * ```typescript
+ * const storeA$ = writable(1);
+ * const storeB$ = writable(1);
+ * const patch = createPatch({a: storeA$, b: storeB$});
+ *
+ * patch({a: 2}) // will perform storeA$.set(2)
+ * patch({a: 2, b: 2}) // will perform storeA$.set(2) and storeB$.set(2) in the same batch.
+ * patch({a: 2, c: 2}) // will perform storeA$.set(2), c is ignored.
+ *
+ * ```
+ * @template T - The type of the object that the stores represent.
+ * @param stores - The stores to be updated.
+ * @returns - A function that takes partial values of the stores and updates them.
+ */
+export declare function createPatch<T extends object>(stores: ToWritableSignal<T>): (storesValues: Partial<T>) => void;
+/**
+ * This utility function is designed to compare the first level of two objects.
+ *
+ * It returns a new object which has all the keys for which the values in `obj1`
+ * and `obj2` are different, with the values from `obj2`, or null if objects
+ * are identical.
+ *
+ * @template T - The type of the objects being compared.
+ * @param obj1 - The first partial object to compare.
+ * @param obj2 - The second partial object to compare.
+ * @returns A partial object containing the properties that have different values, or `null` if the objects are identical.
+ */
+export declare function findChangedProperties<T extends Record<string, any>>(obj1: Partial<T>, obj2: Partial<T>): Partial<T> | null;
+/**
+ * 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`.
+ * If a normalizeValue function is passed in the options, it is called to normalize non-undefined values coming
+ * either from the `config$` store or from the `set` or `update` functions. If a value is invalid (i.e. normalizeValue
+ * returns the `invalidValue` symbol), an error is logged on the console and it is either not set (if it comes from the
+ * `set` or `update` functions), or the `defValue` is used instead (if the invalid value comes from the `config$` store).
+ *
+ * @template T - The type of the value.
+ *
+ * @param defValue - Default value used when both the own value and the config$ value are undefined.
+ * @param config$ - Store containing the default value used when the own value is undefined
+ * @param options - Object which can contain the following optional functions: normalizeValue and equal
+ * @param own$ - Store containing the own value
+ * @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>;
+/**
+ * Returns true if the provided argument is a store (ReadableSignal).
+ * @param x - argument that is tested
+ * @returns true if the argument is a store (ReadableSignal)
+ */
+export declare const isStore: (x: any) => x is ReadableSignal<any>;
+/**
+ * If the provided argument is already a store, it is returned as is, otherwise, a readable store is created with the provided argument as its initial value.
+ * @template T - The type of the value.
+ * @param x - The value to be converted to a readable store.
+ * @returns - The readable store containing the value.
+ */
+export declare const toReadableStore: <T>(x: ReadableSignal<T> | T) => ReadableSignal<T>;
+/**
+ * Converts a value or a writable signal into a writable signal.
+ *
+ * @template T - The type of the value or signal.
+ * @param x - The value or writable signal to convert.
+ * @returns - The resulting writable signal.
+ */
+export declare const toWritableStore: <T>(x: WritableSignal<T> | T) => WritableSignal<T>;
+/**
+ * Normalizes configuration stores by converting them into readable signals.
+ *
+ * @template T - The type of the configuration object.
+ * @param keys - An array of keys to normalize from the configuration object.
+ * @param [config] - The configuration object or readable signals to normalize.
+ * @returns An object containing readable signals for each key in the configuration.
+ */
+export declare const normalizeConfigStores: <T extends object>(keys: (keyof T)[], config?: ReadableSignal<Partial<T>> | ValuesOrReadableSignals<T>) => ReadableSignals<T>;
+/**
+ * Merges two configuration stores into one, prioritizing the first store's values
+ * when both stores have a value for the same key.
+ *
+ * @template T - The type of the configuration object.
+ * @param keys - The keys to merge from the configuration stores.
+ * @param [config1] - The first configuration store.
+ * @param [config2] - The second configuration store.
+ * @returns - The merged configuration store.
+ */
+export declare const mergeConfigStores: <T extends object>(keys: (keyof T)[], config1?: ReadableSignals<T>, config2?: ReadableSignals<T>) => ReadableSignals<T>;
+/**
+ * Returns an object containing, for each property of `defConfig`, a corresponding writable with the normalization and default value logic
+ * described in {@link writableWithDefault}. Keys in the returned object are the same as the ones present in `defConfig`,
+ * with the exta `$` suffix (showing that they are stores).
+ *
+ * @template T - The type of the default configuration object.
+ *
+ * @param defConfig - object containing, for each property, a default value to use in case `config$` does not provide the suitable default
+ * value for that property
+ * @param propsConfig - object defining the config and props
+ * @param options - object containing, for each property of `defConfig`, an optional object with the following optional functions: normalizeValue and equal
+ * @returns an object containing writables
+ *
+ * @example With a store
+ * ```ts
+ * const defConfig = {propA: 1};
+ * const validation = {propA: {normalizeValue: value => +value}};
+ * const config = writable({propA: 5});
+ * const {propA$} = writablesWithDefault(defConfig, {config}, validation);
+ * ```
+ *
+ * @example With an object containing a value and a store
+ * ```ts
+ * const defConfig = {propA: 1, propB: 2};
+ * const validation = {propA: {normalizeValue: value => +value}};
+ * const config = {propA: 5, propB: writable(3)};
+ * const {propA$, propB$} = writablesWithDefault(defConfig, {config}, validation);
+ * ```
+ */
+export declare const writablesWithDefault: <T extends object>(defConfig: T, propsConfig?: PropsConfig<T>, options?: ConfigValidator<T>) => ToWritableSignal<T>;
+/**
+ * Shortcut for calling both {@link writablesWithDefault} and {@link createPatch} in one call.
+ *
+ * @template T - The type of the properties configuration object.
+ * @param defConfig - object containing, for each property, a default value to use in case `config` does not provide the suitable default
+ * value for that property
+ * @param propsConfig - either a store of objects containing, for each property of `defConfig`, the default value or an object containing
+ * for each property of `defConfig` either a store containing the default value or the default value itself
+ * @param options - object containing, for each property of `defConfig`, an optional object with the following optional functions: normalizeValue and equal
+ * @returns an array with two items: the first one containing the writables (returned by {@link writablesWithDefault}),
+ * and the second one containing the patch function (returned by {@link createPatch})
+ *
+ * @example With a store
+ * ```ts
+ * const defConfig = {propA: 1};
+ * const validation = {propA: {normalizeValue: value => +value}};
+ * const config$ = writable({propA: 5});
+ * const [{propA$}, patch] = writablesForProps(defConfig, config$, validation);
+ * ```
+ *
+ * @example With an object containing a value and a store
+ * ```ts
+ * const defConfig = {propA: 1, propB: 2};
+ * const validation = {propA: {normalizeValue: value => +value}};
+ * const config = {propA: 5, propB: writable(3)};
+ * const [{propA$, propB$}, patch] = writablesForProps(defConfig, config, validation);
+ * ```
+ */
+export declare const writablesForProps: <T extends object>(defConfig: T, propsConfig?: PropsConfig<T>, options?: { [K in keyof T]: WritableWithDefaultOptions<T[K]> | undefined; }) => [ToWritableSignal<T>, ReturnType<typeof createPatch<T>>];
+/**
+ * Using input stores, this function builds an object containing the stores as readable and a global state.
+ *
+ * @template A - The type of the state object.
+ * @param inputStores - the input stores
+ * @returns the object containing the stores as readable and the global state
+ */
+export declare const stateStores: <A extends object>(inputStores: { [K in keyof A as `${K & string}$`]: ReadableSignal<any>; }) => {
+    state$: ReadableSignal<A>;
+    stores: { [K in keyof A as `${K & string}$`]: ReadableSignal<A[K]>; };
+};
+/**
+ * Creates a writable signal that derives its value from multiple stores and allows for custom adjustment and equality checks.
+ *
+ * @template T - The type of the derived value.
+ * @template U - A tuple type where the first element is a writable signal of type T and the rest are store inputs.
+ *
+ * @param onChange$ - A readable signal that emits a function to be called when the derived value changes.
+ * @param stores - A tuple of stores where the first element is a writable signal of type T and the rest are store inputs.
+ * @param adjustValue - A function to adjust the derived value based on the input values from the stores.
+ * @param equal - A function to compare the current and new values for equality.
+ *
+ * @returns A writable signal that derives its value from the provided stores and allows for custom adjustment and equality checks.
+ */
+export declare const bindableDerived: <T, U extends [WritableSignal<T>, ...StoreInput<any>[]]>(onChange$: ReadableSignal<(value: T) => void>, stores: U, adjustValue?: (arg: StoresInputValues<U>) => T, equal?: (currentValue: T, newValue: T) => boolean) => WritableSignal<T>;
+/**
+ * Creates a bindable property that synchronizes a writable signal with an optional adjustment function and equality check.
+ *
+ * @template T - The type of the value being stored.
+ * @param store$ - The writable signal that holds the current value.
+ * @param onChange$ - A readable signal that triggers a callback when the value changes.
+ * @param [adjustValue] - An optional function to adjust the value before storing it. Defaults to the identity function.
+ * @param [equal] - An optional function to compare values for equality. Defaults to `tansuDefaultEqual`.
+ * @returns A writable signal that synchronizes with the provided store and triggers the onChange callback when updated.
+ */
+export declare const bindableProp: <T>(store$: WritableSignal<T, T | undefined>, onChange$: ReadableSignal<(newValue: T) => void>, adjustValue?: (value: T) => T, equal?: (a: T, b: T) => boolean) => WritableSignal<T>;
+/**
+ * Wraps an id store in a computed so that undefined and empty values are replaced by a generated id.
+ *
+ * @param id$ - the id store to use
+ * @returns the id store with a default generation if the id is not provided
+ */
+export declare function idWithDefault(id$: ReadableSignal<string>): ReadableSignal<string>;
+export declare const true$: ReadableSignal<true>;
+export declare const false$: ReadableSignal<false>;