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

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

@@ -1,98 +0,0 @@
-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

@@ -1,8 +0,0 @@
-/**
- * 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

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,17 +0,0 @@
-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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,54 +0,0 @@
-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

@@ -1,172 +0,0 @@
-"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

@@ -1,224 +0,0 @@
-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>;