solid-new-bucket/dist/index.d.mts

Better Signal API for SolidJS

import { Accessor, SignalOptions, Context } from 'solid-js';

/**
 * Filter out and remove elements from array.
 * @param arr array
 * @param filter filter
 * @returns new array
 */
declare function removeElementsFromArray<T>(arr: T[], filter: (t: T) => boolean): T[];
/**
 * Copy range or array.
 * @param arr array
 * @param start start pos
 * @param end end pos
 * @returns sub range of array
 */
declare function copyOfRange<T>(arr: T[], start: number, end: number): T[];
/**
 * Find first element in array which passes test.
 * @param arr array
 * @param test test
 * @returns index
 */
declare function indexOf<T>(arr: T[], test: Func<T, boolean>): number;

/**
 * Stamped Bucket help to trigger rerendering after updating object without recreate new object.
 * @returns StampedBucket<T>
 */
declare function stampedBucket<T>(value: T, options?: {
    beforeUpdate?: (value: T) => void;
    afterUpdate?: (value: T) => void;
    localStorageName?: string;
}): StampedBucket<T>;
declare function asBucket<O, FieldType, DecadeType>(s: StampedBucket<O>, path: ObjectIndex[], mapper?: Mapper<FieldType, DecadeType>): Bucket<FieldType>;
declare function asAccessor<T, K extends (keyof T)>(v: T | Accessor<T>, k: K): Accessor<T[K]>;
/**
 * Create a bucket to track data.
 * @param value value or Accessor of value
 * @param options options
 * @returns Bucket<T>
 */
declare function bucket<T>(value: T | Accessor<T>, options?: {
    useValueAsAccessor?: boolean;
    beforeUpdate?: (newValue: T) => void;
    afterUpdate?: (newValue: T) => void;
    localStorageName?: string;
} & SignalOptions<T>): Bucket<T>;

/**
 * Check if array or string is not empty.
 * @param v array of any, string or undefined
 * @returns true if target is not empty
 */
declare function isNotEmpty<T>(v?: T[]): boolean;
declare function isNotEmpty(v?: string): boolean;
/**
 * Check if value is number.
 * @param v any
 * @returns true if value is number
 */
declare function isNumber(v: any): boolean;
/**
 * Compare two date string.
 * @param a date 1
 * @param b date 2
 * @returns true if a is later than b
 */
declare function compareDateString(a: string, b: string): number;
/**
 * Check whether there is an element in b exists in a as well.
 * @param a array 1
 * @param b array 2
 * @returns boolean
 */
declare function containsAny(a: any[], b: any[]): boolean;

/**
 * Parse and format timestamp from number to string.
 * @param timestamp time
 * @param showTime show only date if false
 * @param showMilliseconds show ms if true
 * @returns formatted string
 */
declare function parseTimestamp(timestamp: number, showTime?: boolean, showMilliseconds?: boolean): string;
declare function toCapital(v: string): string;

/**
 * Genereate a sequence.
 * @param start start
 * @param end end
 * @param step step
 * @returns array
 */
declare function sequence(start: number, end: number, step?: number): number[];
/**
 * Generate a array of size.
 * @param size size
 * @returns
 */
declare function iterate(size: number): number[];

declare function useCtx<T>(c: Context<T>): T;
declare function names(...v: (string | undefined)[]): string;
declare function clone(obj: any): any;

declare function wrapDateNumber(v: number, bits?: number): string | number;
declare function wrapString(v: any): string;
declare function wrapNumber(v: any): number;

/**
 * Invoke function or return value if condition is true.
 * @param condition any
 * @param value function to be invoked or value to be return
 * @param defaultValue fallback value, optional
 */
declare function conditional<T>(condition: any, value: () => void): void;
declare function conditional<T>(condition: any, value: T, defaultValue?: T): T;
declare function conditional<T>(condition: any, value: Supplier<T>, defaultValue?: T): T;

type Pair<K, V> = [key: K, value: V];
type Consumer<T> = (v: T) => void;
type BiConsumer<A, B> = (a: A, b: B) => void;
type TriConsumer<A, B, C> = (a: A, b: B, c: C) => void;
type Func<T, R> = (v: T) => R;
type BiFunc<A, B, R> = (a: A, b: B) => R;
type Callback = (...args: any) => any;
type Supplier<T> = () => T;
type Comparator<T> = (a: T, b: T) => -1 | 0 | 1;
type ObjectIndex = string | number;
interface Mapper<A, B> {
    to?(a: A): B;
    from?(b: B): A;
}
type Bucket<T> = {
    <U extends T>(v?: T): U;
    <U extends T>(v: (prev: T) => U): U;
};
type StampedBucket<T> = ((updater?: Consumer<T>) => T) & StampedBucketAction<T>;
interface StampedBucketAction<T> {
    map<O>(call: (v: T) => O): O;
    markChanged(): void;
    reset(v: T): void;
}
interface StampedData<T> {
    data: T;
    timestamp: number;
}

export { type BiConsumer, type BiFunc, type Bucket, type Callback, type Comparator, type Consumer, type Func, type Mapper, type ObjectIndex, type Pair, type StampedBucket, type StampedData, type Supplier, type TriConsumer, asAccessor, asBucket, bucket, clone, compareDateString, conditional, containsAny, copyOfRange, indexOf, isNotEmpty, isNumber, iterate, names, parseTimestamp, removeElementsFromArray, sequence, stampedBucket, toCapital, useCtx, wrapDateNumber, wrapNumber, wrapString };