@rebilly/revel 4.21.2 → 5.0.0

package/dist/components/r-repeater/r-repeater.vue.d.ts

@@ -0,0 +1,58 @@
+import { type PropType } from 'vue';
+interface State {
+    isLoading: boolean;
+    rows: object[];
+}
+declare const _default: import("vue").DefineComponent<{
+    /**
+     * Returns some data to be rendered by the default scoped slot
+     */
+    provider: {
+        type: PropType<() => object[] | object[] | Promise<object[]>>;
+        required: true;
+    };
+    /**
+     * Defines if the loading state is fullscreen
+     */
+    isLoaderFullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Defines the property, which changes will trigger the fetching of data
+     */
+    watcher: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}, unknown, State, {
+    hasRows(): boolean;
+}, {
+    fetchData(): Promise<void>;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * Returns some data to be rendered by the default scoped slot
+     */
+    provider: {
+        type: PropType<() => object[] | object[] | Promise<object[]>>;
+        required: true;
+    };
+    /**
+     * Defines if the loading state is fullscreen
+     */
+    isLoaderFullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * Defines the property, which changes will trigger the fetching of data
+     */
+    watcher: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>>, {
+    watcher: Record<string, any>;
+    isLoaderFullscreen: boolean;
+}>;
+export default _default;

package/dist/components/r-select/async-extension.d.ts

@@ -0,0 +1,91 @@
+import type { CreateComponentPublicInstance } from 'vue';
+import type { Query, Value, CacheItem, Methods, AsyncSearchFn, Options } from './types';
+import type { Nullable, Optional } from '../../types';
+export type CacheValuePrefix = (value: unknown) => string;
+export interface Config {
+    limit: number;
+    minValueLength: number;
+    cacheExpirationTime: number;
+    debounceDelay: number;
+}
+interface Cache {
+    lastRequestId: number;
+    itemsByKey: {
+        [key: string]: CacheItem;
+    };
+    lastKey: Nullable<string>;
+}
+export interface Component extends CreateComponentPublicInstance {
+    async: {
+        cache: Cache;
+        query: Query;
+        isLoading: boolean;
+    };
+}
+interface ConstructorPayload {
+    component: Component;
+    config: Config;
+    asyncGetInitValue: AsyncSearchFn;
+    asyncFind: AsyncSearchFn;
+    prepareCacheValuePrefix: CacheValuePrefix;
+}
+export declare class AsyncExtension {
+    private component;
+    private config;
+    private prepareCacheValuePrefix;
+    private methodsmap;
+    private cache;
+    private query;
+    isLoading: boolean;
+    findByValue: (value: Value) => Promise<void>;
+    findBySearch: (value: Value) => Promise<void>;
+    loadMore: (count: number) => Promise<void>;
+    loadByQuery: (query: Partial<Query>) => Promise<void>;
+    private static defaultConfig;
+    private static findMethodTypes;
+    constructor({ component, config, asyncGetInitValue, asyncFind, prepareCacheValuePrefix, }: ConstructorPayload);
+    static prepareConfig(config: Config): Config;
+    static makeCacheKey({ type, value, limit, offset, }: {
+        type: Methods;
+        value: string;
+        limit: number;
+        offset: number;
+    }): string;
+    static validateCacheData(data: Optional<CacheItem>, { expiration }: {
+        expiration: number;
+    }): boolean;
+    getConfig(): Readonly<{
+        limit: number;
+        minValueLength: number;
+        cacheExpirationTime: number;
+        debounceDelay: number;
+    }>;
+    getLastCachedFindResult(): CacheItem | undefined;
+    getLastCachedSearchFindResult(): CacheItem | undefined;
+    /** Returns actual query offset value. */
+    getOffset(): number;
+    /** Manual sets offset value. */
+    setOffset(offset: number): void;
+    /** Returns actual query limit value. */
+    getLimit(): number;
+    /** Returns true if last request has any options. */
+    hasOptions(): boolean;
+    find(type: Methods, value: Value, params?: Partial<Query>): Promise<void>;
+    private baseFindByValue;
+    private baseFindBySearch;
+    findNext(): Promise<void>;
+    findPrev(): Promise<void>;
+    baseLoadMore(count: number): Promise<void>;
+    baseLoadByQuery({ limit, offset }: Partial<Query>): Promise<void>;
+    getFromCache(key: Nullable<string>): CacheItem | undefined;
+    getAllCacheItems(): CacheItem[];
+    saveToCache({ key, type, options, value, query, }: {
+        key: string;
+        type: Methods;
+        options: Options;
+        value: Value;
+        query: Query;
+    }): void;
+    handleLoaded(): void;
+}
+export {};