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

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>, displayName?: string): T;
type UseFunc<T> = () => T;
/**
 * Create context and use function
 * @returns [context, useContext]
 */
declare function context<T>(displayName?: string): [Context<T | undefined>, UseFunc<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;

declare class DisposableSupport {
    protected readonly dc: DisposableCollector;
    constructor();
}
declare class DisposableCollector implements IDisposableCollector {
    private dc;
    size(): number;
    collect(disposable: IDisposable): void;
    disposeAll(): void;
}

type EventHandler = (...args: any[]) => void | EventHandlingResult | Promise<void | EventHandlingResult>;
type EventDefinitions = Record<string, EventHandler>;
type Events<D extends EventDefinitions> = {
    [K in keyof D]: K;
};
interface IEventRegistry<ED extends EventDefinitions> {
    emit<E extends keyof ED>(event: E, ...args: Parameters<ED[E]>): any;
    emitAsync<E extends keyof ED>(event: E, ...args: Parameters<ED[E]>): Promise<any>;
    /**
     * Listen event.
     *
     * @deprecated
     * @param event
     * @param callback
     * @returns disposable
     */
    on<E extends keyof ED>(event: E, callback: ED[E]): IDisposable;
    /**
     * Listen event.
     * @param event
     * @param callback
     * @param dc disposable collector
     */
    on<E extends keyof ED>(event: E, callback: ED[E], dc: IDisposableCollector): void;
    once<E extends keyof ED>(event: E, callback: ED[E]): void;
}
declare enum EventHandlingAction {
    Forward = 0,
    Terminate = 1
}
declare function forward(params?: any): EventHandlingResult;
declare function terminate(params?: any): EventHandlingResult;
interface EventHandlingResult {
    action: EventHandlingAction;
    params: any;
}
declare abstract class SimpleEventRegistry<ED extends EventDefinitions> implements IEventRegistry<ED> {
    private registry;
    emit<E extends keyof ED>(event: E, ...args: Parameters<ED[E]>): any;
    emitAsync<E extends keyof ED>(event: E, ...args: Parameters<ED[E]>): Promise<any>;
    /**
     * Listen event.
     *
     * @deprecated
     * @param event
     * @param callback
     * @returns disposable
     */
    on<E extends keyof ED>(event: E, callback: ED[E]): IDisposable;
    on<E extends keyof ED>(event: E, callback: ED[E], dc: IDisposableCollector): void;
    once<E extends keyof ED>(event: E, callback: ED[E]): void;
    private off;
}
declare class Trace {
    readonly source: any;
    readonly parent?: any;
    constructor(source: any, parent?: any);
}

interface HandleProps<T> {
    handle?: Handle<T>;
}
interface HandleFuncs<T> {
    get mounted(): boolean;
    safeAccess<K extends keyof T, E = T[K]>(key: K): E | undefined;
}
interface HandleHook {
    onMount(callback: Consumer<IDisposableCollector>): void;
    /**
     * Called when all SolidJS onMount hooks are invoked.
     * @param callback callback
     */
    onReady(callback: Consumer<IDisposableCollector>): void;
    onCleanup(callback: Callback): void;
}
interface HasMount {
    mount(target: any): void;
}
interface HasCleanup {
    cleanup(): void;
}
interface HasMounted {
    get mounted(): boolean;
}
interface HasSafeAccess<T> {
    safeAccess<K extends keyof T, E = T[K]>(key: K): E | undefined;
}
interface HasOnMount {
    onMount: (callback: Consumer<IDisposableCollector>) => void;
}
interface HasOnReady {
    onReady: (callback: Consumer<IDisposableCollector>) => void;
}
interface HasOnCleanup {
    onCleanup: (callback: Callback) => void;
}
type Handle<T> = T extends (HasMount | HasCleanup | HasMounted | HasSafeAccess<T> | HasOnMount | HasOnReady | HasOnCleanup) ? never : T & HandleFuncs<T> & HandleHook;
declare function handle<T extends Object>(): Handle<T>;
declare function completeHandle<T extends Object, I extends T>(target: I, handle?: Handle<T>): void;
declare class HandleTarget<T> extends DisposableSupport {
    constructor(handle?: Handle<T>);
}
declare class EventSupportedHandleTarget<T, ET extends EventDefinitions> extends SimpleEventRegistry<ET> {
    protected readonly dc: DisposableCollector;
    constructor(handle?: Handle<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> = {
    /**
     * Update.
     *  @param v: value
     */
    <U extends T>(v?: T): U;
    /**
     * Update with updater.
     *  @param v: updater
     */
    <U extends T>(v: (prev: T) => U): U;
};
type StampedBucket<T> = ((updater?: Consumer<T>) => T) & StampedBucketAction<T>;
interface StampedBucketAction<T> {
    /**
     * Provide mapper to map content to needed type.
     * @param call mapper
     */
    map<O>(call: (v: T) => O): O;
    /**
     * Mark content is changed.
     */
    markChanged(): void;
    /**
     * Set content to.
     * @param v
     */
    reset(v: T): void;
}
interface StampedData<T> {
    data: T;
    timestamp: number;
}
interface IDisposable {
    dispose(): void;
}
interface IDisposableCollector {
    collect(disposable: IDisposable): void;
}

export { type BiConsumer, type BiFunc, type Bucket, type Callback, type Comparator, type Consumer, DisposableCollector, DisposableSupport, type EventDefinitions, type EventHandlingResult, EventSupportedHandleTarget, type Events, type Func, type Handle, type HandleProps, HandleTarget, type IDisposable, type IDisposableCollector, type IEventRegistry, type Mapper, type ObjectIndex, type Pair, SimpleEventRegistry, type StampedBucket, type StampedData, type Supplier, Trace, type TriConsumer, asAccessor, asBucket, bucket, clone, compareDateString, completeHandle, conditional, containsAny, context, copyOfRange, forward, handle, indexOf, isNotEmpty, isNumber, iterate, names, parseTimestamp, removeElementsFromArray, sequence, stampedBucket, terminate, toCapital, useCtx, wrapDateNumber, wrapNumber, wrapString };