native-document 1.0.14 → 1.0.16-8.1

package/types/observable.d.ts

@@ -0,0 +1,227 @@
+import {FilterResult, PredicateMap} from "./filters";
+
+export type Unsubscribe = () => void;
+
+export type FormatType = 'currency' | 'number' | 'percent' | 'date' | 'time' | 'datetime' | 'relative' | 'plural';
+
+export interface FormatOptions {
+    // currency
+    currency?: string;
+    notation?: 'standard' | 'scientific' | 'engineering' | 'compact';
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    // percent
+    decimals?: number;
+    // date / datetime
+    dateStyle?: 'full' | 'long' | 'medium' | 'short';
+    format?: string;
+    // time / datetime
+    hour?: '2-digit' | 'numeric';
+    minute?: '2-digit' | 'numeric';
+    second?: '2-digit' | 'numeric';
+    // relative
+    unit?: 'day' | 'week' | 'month' | 'year' | 'hour' | 'minute' | 'second';
+    numeric?: 'always' | 'auto';
+    // plural
+    singular?: string;
+    plural?: string;
+}
+
+export interface FormattersStatic {
+    currency(value: number, locale: string, options?: FormatOptions): string;
+    number(value: number, locale: string, options?: FormatOptions): string;
+    percent(value: number, locale: string, options?: FormatOptions): string;
+    date(value: Date | number, locale: string, options?: FormatOptions): string;
+    time(value: Date | number, locale: string, options?: FormatOptions): string;
+    datetime(value: Date | number, locale: string, options?: FormatOptions): string;
+    relative(value: Date | number, locale: string, options?: FormatOptions): string;
+    plural(value: number, locale: string, options?: FormatOptions): string;
+    [key: string]: (value: any, locale: string, options?: FormatOptions) => string;
+}
+
+export declare const Formatters: FormattersStatic;
+
+
+// Observable system type definitions
+export interface ObservableItem<T = any> {
+    readonly $currentValue: T;
+    readonly $previousValue: T;
+    readonly $initialValue: T | null;
+    readonly $isCleanedUp: boolean;
+
+    $value: T;
+    $memoryId: number | null;
+
+    val(): T;
+    set(value: T | ((prev: T) => T)): void;
+    trigger(operations?: ObservableOperation): void;
+    cleanup(): void;
+
+    subscribe(callback: (current: T, previous: T, operations?: ObservableOperation) => void): Unsubscribe;
+    unsubscribe(callback: Function): void;
+    on(value: T, callback: ObservableItem<boolean> | ((isActive: boolean) => void)): () => void;
+
+    check<U>(callback: (value: T) => U): ObservableChecker<U>;
+    transform<U>(callback: (value: T) => U): ObservableChecker<U>;
+    is<U>(callback: (value: T) => U): ObservableChecker<U>;
+    select<U>(callback: (value: T) => U): ObservableChecker<U>;
+    pluck<U>(callback: (value: T) => U): ObservableChecker<U>;
+    format(type: FormatType | ((value: T) => string), options?: FormatOptions): ObservableItem<string>;
+    get(key: string | number): any;
+    when(value: T): ObservableWhen<T>;
+    off(value: T, callback?: Function): void;
+    once(predicate: T | ((value: T) => boolean), callback: (value: T) => void): void;
+    onCleanup(callback: () => void): void;
+    intercept(callback: (newValue: T, currentValue: T) => T | undefined): this;
+    persist(key: string, options?: {
+        get?: (value: any) => T;
+        set?: (value: T) => any;
+    }): this;
+    disconnectAll(): void;
+
+    toString(): string;
+    equals(value: any): boolean;
+    toBool(): boolean;
+    toggle(): void;
+    reset(): void;
+}
+
+export class ObservableWhen<T = any> {
+    readonly __$isObservableWhen: true;
+    private $target: T;
+    private $observer: ObservableItem<T>;
+
+    constructor(observer: ObservableItem<T>, value: T);
+
+    subscribe(callback: (value: boolean) => void): Unsubscribe;
+    val(): boolean;
+    isMatch(): boolean;
+    isActive(): boolean;
+}
+
+export interface ObservableOperation {
+    action?: string;
+    args?: any[];
+    result?: any;
+}
+
+export interface ObservableChecker<T = any> {
+    readonly __$isObservableChecker: true;
+
+    subscribe(callback: (value: T) => void): Unsubscribe;
+    check<U>(callback: (value: T) => U): ObservableChecker<U>;
+    val(): T;
+
+    set(value: any): void;
+    trigger(): void;
+    cleanup(): void;
+}
+
+export interface ObservableArray<T> extends ObservableItem<T[]> {
+    readonly length: number;
+
+    push(...items: T[]): number;
+    pop(): T | undefined;
+    shift(): T | undefined;
+    unshift(...items: T[]): number;
+    reverse(): T[];
+    sort(compareFn?: (a: T, b: T) => number): T[];
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+
+    isEmpty(): boolean;
+    clear(): boolean;
+    merge(values: T[]): void;
+    removeItem(item: T): T[];
+    remove(index: number): T[];
+    swap(indexA: number, indexB: number): boolean;
+    count(condition: (item:T, index?:number) => boolean): number;
+    populateAndRender(iteration: number, callback: (index: number) => T): void;
+
+    map<U>(callback: (value: T, index: number, array: T[]) => U): U[];
+    filter(callback: (value: T, index: number, array: T[]) => boolean): T[];
+    reduce<U>(callback: (acc: U, value: T, index: number, array: T[]) => U, initial: U): U;
+    some(callback: (value: T, index: number, array: T[]) => boolean): boolean;
+    every(callback: (value: T, index: number, array: T[]) => boolean): boolean;
+    find(callback: (value: T, index: number, array: T[]) => boolean): T | undefined;
+    at(index: number): T | undefined;
+    findIndex(callback: (value: T, index: number, array: T[]) => boolean): number;
+    concat(...items: (T | T[])[]): T[];
+
+    where(predicates: PredicateMap<T>): ObservableArray<T>;
+    whereSome<K extends keyof T>(fields: K[], filter: FilterResult<T[K]>): ObservableArray<T>;
+    whereEvery<K extends keyof T>(fields: K[], filter: FilterResult<T[K]>): ObservableArray<T>;
+
+    deepSubscribe(callback: (value: T[]) => void): () => void;
+}
+
+export type ObservableObject<T extends Record<string, any>> = ObservableItem<T> & {
+    readonly __$isObservableObject: true;
+    readonly __isProxy__: true;
+    readonly $observables: { [K in keyof T]: ObservableItem<T[K]> };
+    readonly configs: ObservableConfig | null;
+
+    $load(initialValue: Partial<T>): void;
+    $val(): T;
+    val(): T;
+    get(key: string): any;
+    $get(key: string): any;
+    set(values: Partial<T>): void;
+    $set(values: Partial<T>): void;
+    $updateWith(values: Partial<T>): void;
+    update(values: Partial<T>): void;
+    reset(): void;
+    clone(): ObservableObject<T>;
+    $clone(): ObservableObject<T>;
+    keys(): string[];
+    $keys(): string[];
+    observables(): ObservableItem<any>[];
+} & {
+    [K in keyof T]: T[K] extends (infer U)[]
+        ? ObservableArray<U>
+        : T[K] extends Record<string, any>
+            ? ObservableObject<T[K]>
+            : ObservableItem<T[K]>;
+};
+
+
+export interface BatchFunction<TArgs extends any[] = any[], TReturn = any> {
+    (...args: TArgs): TReturn;
+    readonly $observer: ObservableItem<number>;
+}
+
+export type ValidComputedDependencies = Array<ObservableItem | ObservableArray<any> | ObservableChecker | ObservableObject<any>>;
+
+export interface AutoCleanupOptions {
+    interval?: number;
+    threshold?: number;
+}
+
+export interface ObservableConfig {
+    deep?: boolean;
+    reset?: boolean;
+    propagation?: boolean;
+}
+
+export interface ObservableStatic {
+    <T>(value: T, configs?: ObservableConfig | null): ObservableItem<T>;
+    array<T>(target: T[] | null, configs?: ObservableConfig | null): ObservableArray<T>;
+
+    init<T extends Record<string, any>>(value: T, configs?: ObservableConfig | null): ObservableObject<T>;
+    object<T extends Record<string, any>>(value: T, configs?: ObservableConfig | null): ObservableObject<T>;
+    json<T extends Record<string, any>>(value: T, configs?: ObservableConfig | null): ObservableObject<T>;
+
+    computed<T>(callback: () => T, dependencies?: ValidComputedDependencies | BatchFunction): ObservableItem<T>;
+    computed<T>(callback: () => T, batchFunction?: BatchFunction): ObservableItem<T>;
+
+    batch<TArgs extends any[], TReturn>(
+        callback: (...args: TArgs) => TReturn
+    ): BatchFunction<TArgs, TReturn>;
+
+    value(data: any): any;
+    update(target: any, data: any): void;
+
+    getById(id: number): ObservableItem | null;
+    cleanup(observable: ObservableItem): void;
+    autoCleanup(enable?: boolean, options?: AutoCleanupOptions): void;
+    arrayOfObject<T extends Record<string, any>>(data: T[]): ObservableObject<T>[];
+}

package/types/plugins-manager.d.ts

@@ -0,0 +1,65 @@
+import {NDElement} from "./nd-element";
+import {ObservableItem} from "./observable";
+import { Map} from "./polyfill";
+
+type FrameworkEvents = {
+    // Observable Events
+    'CreateObservable': (observable: ObservableItem) => void;
+    'ObservableBeforeChange': (observable: ObservableItem) => void;
+    'ObservableAfterChange': (observable: ObservableItem) => void;
+    'ObservableSubscribe': (observable: ObservableItem, target?: any) => void;
+    'ObservableUnsubscribe': (observable: ObservableItem) => void;
+    'CreateObservableArray': (observer: ObservableItem) => void;
+    'CreateObservableComputed': (observable: ObservableItem, dependencies: ObservableItem[]) => void;
+
+    // Element Events
+    'NDElementCreated': (element: HTMLElement, ndElement: NDElement) => void;
+    'Setup': (element: HTMLElement, attributes?: any, customWrapper?: Function) => void;
+    'BeforeProcessChildren': (parent: HTMLElement | DocumentFragment) => void;
+    'AfterProcessChildren': (parent: HTMLElement | DocumentFragment) => void;
+    'BeforeProcessComponent': (component: Function) => void;
+};
+
+type EventMethodName = `on${Capitalize<keyof FrameworkEvents>}`;
+
+interface Plugin {
+    $name?: string;
+
+    init?(): void;
+    cleanup?(): void;
+
+    // NativeDocument Framework Events
+    onCreateObservable?: (observable: ObservableItem) => void;
+    onObservableBeforeChange?: (observable: ObservableItem) => void;
+    onObservableAfterChange?: (observable: ObservableItem) => void;
+    onObservableSubscribe?: (observable: ObservableItem, target?: any) => void;
+    onObservableUnsubscribe?: (observable: ObservableItem) => void;
+    onCreateObservableArray?: (observer: ObservableItem) => void;
+    onCreateObservableComputed?: (observable: ObservableItem, dependencies: ObservableItem[]) => void;
+    onNDElementCreated?: (element: HTMLElement, ndElement: NDElement) => void;
+    onSetup?: (element: HTMLElement, attributes?: any, customWrapper?: Function) => void;
+    onBeforeProcessChildren?: (parent: HTMLElement | DocumentFragment) => void;
+    onAfterProcessChildren?: (parent: HTMLElement | DocumentFragment) => void;
+    onBeforeProcessComponent?: (component: Function) => void;
+
+    // Other possible events
+    [key: string]: any;
+}
+
+interface IPluginsManager {
+    list(): Map<string, Plugin>;
+
+    add(name: string, plugin: Plugin): void;
+
+    remove(pluginName: string): void;
+
+    emit(event: string, ...data: any[]): void;
+}
+
+declare const PluginsManager: IPluginsManager;
+
+export type TypedPlugin<T extends Record<string, (...args: any[]) => void> = {}> = Plugin & {
+    [K in keyof T as K extends string ? `on${Capitalize<K>}` : never]: T[K];
+};
+
+export default PluginsManager;

package/types/polyfill.d.ts

@@ -0,0 +1,18 @@
+export interface Set<T> {
+    add(value: T): this;
+    clear(): void;
+    delete(value: T): boolean;
+    forEach(callbackFn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    has(value: T): boolean;
+    readonly size: number;
+}
+
+export interface Map<K, V> {
+    clear(): void;
+    delete(key: K): boolean;
+    forEach(callbackFn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): this;
+    readonly size: number;
+}

package/types/property-accumulator.d.ts

@@ -0,0 +1,33 @@
+import {ObservableItem} from "./observable";
+
+type CssPropertyValueType = string | ObservableItem | number;
+type ClassPropertyValueType = boolean | ObservableItem;
+
+export interface CssPropertyAccumulator {
+    add(key: string, value: CssPropertyValueType): void;
+    value(): string | Record<string, CssPropertyValueType>;
+}
+
+export interface ClassPropertyAccumulator {
+    add(key: string, value?: ClassPropertyValueType): void;
+    value(): string | Record<string, ClassPropertyValueType>;
+}
+
+
+type CssInitialValue = string | Record<string, CssPropertyValueType> | string[];
+type ClassInitialValue = string | Record<string, ClassPropertyValueType> | string[];
+
+export declare const cssPropertyAccumulator: (initialValue?: CssInitialValue) => CssPropertyAccumulator;
+
+
+export declare const classPropertyAccumulator: (initialValue?: ClassInitialValue) => ClassPropertyValueType;
+
+// Export des types pour usage externe
+export type {
+    cssPropertyAccumulator as CssPropertyAccumulatorType,
+    classPropertyAccumulator as ClassPropertyAccumulatorType,
+    CssPropertyValueType,
+    ClassPropertyValueType,
+    CssInitialValue,
+    ClassInitialValue
+};

package/types/router.d.ts

@@ -0,0 +1,85 @@
+// Router system type definitions
+import { ValidChild } from './elements';
+import { NDElement } from './nd-element';
+import {ValidChildren} from "./validator";
+
+export interface RouteParams {
+    [key: string]: string;
+}
+
+export interface QueryParams {
+    [key: string]: string;
+}
+
+export interface RouteContext {
+    params: RouteParams;
+    query: QueryParams;
+}
+
+export interface Route {
+    name(): string | null;
+    component(): (context: RouteContext) => HTMLElement | DocumentFragment;
+    middlewares(): Function[];
+    shouldRebuild(): boolean;
+    path(): string;
+    layout(): Function | null;
+    match(path: string): RouteParams | false;
+    url(configs: { params?: RouteParams; query?: QueryParams; basePath?: string }): string;
+}
+
+export interface RouterState {
+    route: Route | null;
+    params: RouteParams | null;
+    query: QueryParams | null;
+    path: string | null;
+    hash: string | null;
+}
+
+export interface Router {
+    routes(): Route[];
+    currentState(): RouterState;
+
+    add(path: string, component: (context: RouteContext) => HTMLElement | DocumentFragment, options?: {
+        name?: string;
+        middlewares?: Function[];
+        shouldRebuild?: boolean;
+        with?: Record<string, string>;
+        layout?: (children: ValidChild) => ValidChild ;
+    }): this;
+
+    group(suffix: string, options: { middlewares?: Function[]; name?: string; layout?: Function }, callback: () => void): this;
+
+    generateUrl(name: string, params?: RouteParams, query?: QueryParams): string;
+    resolve(target: string | { name: string; params?: RouteParams; query?: QueryParams }): {
+        route: Route;
+        params: RouteParams;
+        query: QueryParams;
+        path: string;
+    };
+
+    subscribe(listener: (state: RouterState) => void): () => void;
+
+    push(target: string | { name: string; params?: RouteParams; query?: QueryParams }): void;
+    replace(target: string | { name: string; params?: RouteParams; query?: QueryParams }): void;
+    forward(): void;
+    back(): void;
+
+    init(defaultPath?: string): void;
+    mount(container: string | HTMLElement): HTMLElement;
+}
+
+export interface RouterStatic {
+    create(options: { mode: 'memory' | 'history' | 'hash'; name?: string; entry?: string }, callback: (router: Router) => void): Router;
+    get(name?: string): Router;
+    push(target: string | { name: string; params?: RouteParams; query?: QueryParams }, name?: string): void;
+    replace(target: string | { name: string; params?: RouteParams; query?: QueryParams }, name?: string): void;
+    forward(name?: string): void;
+    back(name?: string): void;
+}
+
+// Link component for router
+export declare const Link: (options: {
+    to?: string | { name: string; params?: RouteParams; query?: QueryParams; router?: string };
+    href?: string;
+    [key: string]: any;
+}, children: ValidChild) => HTMLAnchorElement & { nd: NDElement };

package/types/service.d.ts

@@ -0,0 +1,23 @@
+type ServiceFactory<T> = () => T;
+type MemoizedFactory<T, Args extends any[]> = (...args: Args) => T;
+
+type OnceProxy<T> = {
+    [K in keyof T]: T[K];
+};
+
+type MemoizeProxy<T> = {
+    [key: string]: T;
+    [key: symbol]: T;
+};
+
+interface ServiceStatic {
+    once<T extends object>(fn: ServiceFactory<T>): OnceProxy<T>;
+
+    memoize<T>(fn: () => T): MemoizeProxy<T>;
+
+    memoize<T, Args extends any[]>(
+        fn: (...args: Args) => T
+    ): MemoizeProxy<(...args: Args) => T>;
+}
+
+export const Service: ServiceStatic;

package/types/singleton.d.ts

@@ -0,0 +1,19 @@
+import { AnchorDocumentFragment } from "./elements";
+
+export type ViewCreator = (instance: SingletonView) => Node;
+
+export type SectionFunction = (...args: any[]) => Node | Node[];
+
+export type ComponentUpdater = (...args: any[]) => void;
+
+export type ComponentsMap = Record<string, ComponentUpdater>;
+
+export declare class SingletonView {
+    constructor(viewCreator: ViewCreator);
+
+    render(data: any[]): Node;
+
+    createSection(name: string, fn?: SectionFunction): AnchorDocumentFragment;
+}
+
+export declare function useSingleton(fn: ViewCreator): (...args: any[]) => Node;

package/types/store.d.ts

@@ -0,0 +1,63 @@
+import { ObservableItem } from './observable';
+import { Set } from "./polyfill";
+
+export type StoreGroupInstance = StoreStatic & {
+    readonly $name: string;
+};
+
+export type StoreReadonlyInstance = Omit<StoreStatic,
+    | 'use'
+    | 'get'
+    | 'create'
+    | 'createResettable'
+    | 'createComposed'
+    | 'createPersistent'
+    | 'createPersistentResettable'
+    | 'delete'
+    | 'reset'
+> & {
+    use(name: string): never;
+    get(name: string): never;
+    create(name: string, value: unknown): never;
+    createResettable(name: string, value: unknown): never;
+    createComposed(name: string, computation: () => unknown, dependencies: unknown[]): never;
+    createPersistent(name: string, value: unknown, localStorageKey?: string): never;
+    createPersistentResettable(name: string, value: unknown, localStorageKey?: string): never;
+    delete(name: string): never;
+    reset(name: string): never;
+};
+
+export interface StoreStatic {
+    create<T>(name: string, value: T): ObservableItem<T>;
+    createResettable<T>(name: string, value: T): ObservableItem<T>;
+    createComposed<T>(
+        name: string,
+        computation: () => T,
+        dependencies: (string | ObservableItem<unknown>)[]
+    ): ObservableItem<T>;
+    createPersistent<T>(name: string, value: T, localStorageKey?: string): ObservableItem<T>;
+    createPersistentResettable<T>(name: string, value: T, localStorageKey?: string): ObservableItem<T>;
+
+    has(name: string): boolean;
+    get<T>(name: string): ObservableItem<T> | null;
+    getWithSubscribers<T>(name: string): {
+        observer: ObservableItem<T>;
+        subscribers: Set<ObservableItem<T>>;
+    } | null;
+
+    use<T>(name: string): ObservableItem<T>;
+    follow<T>(name: string): Readonly<ObservableItem<T>>;
+
+    reset(name: string): void;
+    delete(name: string): void;
+
+    group(callback: (group: StoreGroupInstance) => void): StoreGroupInstance;
+    group(name: string, callback: (group: StoreGroupInstance) => void): StoreGroupInstance;
+
+    protected(): StoreReadonlyInstance;
+
+    readonly [key: string]: ObservableItem<unknown> | unknown;
+}
+
+export declare const StoreFactory: () => StoreStatic;
+export declare const Store: StoreStatic;

package/types/template-cloner.ts

@@ -0,0 +1,43 @@
+
+interface BindingData {
+    attributes?: Record<string, (...data: any[]) => any>;
+    classes?: Record<string, (...data: any[]) => any>;
+    styles?: Record<string, (...data: any[]) => any>;
+    value?: (...data: any[]) => any;
+    attach?: (element: Element, ...data: any[]) => void;
+}
+
+interface ProcessedAttributes {
+    class?: Record<string, any>;
+    style?: Record<string, any>;
+    [key: string]: any;
+}
+
+export interface BindingHydrator {
+    $hydrate: (element: Element | Text, property?: string) => void;
+}
+
+export type TemplateBuilder = (templateCloner: TemplateCloner) => Node;
+
+type CachedTemplateFunction = (...args: any[]) => Node;
+
+export declare class TemplateCloner {
+    constructor($fn: TemplateBuilder);
+
+    clone(data: any[]): Node;
+
+    style(fn: (...data: any[]) => any): BindingHydrator;
+    class(fn: (...data: any[]) => any): BindingHydrator;
+    value(callbackOrProperty: string | ((...data: any[]) => any)): BindingHydrator;
+    text(callbackOrProperty: string | ((...data: any[]) => any)): BindingHydrator;
+    attr(fn: (...data: any[]) => any): BindingHydrator;
+    event(fn: (event: Event, ...data: any[]) => void): BindingHydrator;
+
+    property(propertyName: string): BindingHydrator;
+    property(fn: (...data: any[]) => any): BindingHydrator;
+
+    attach(fn: (element: Element, ...data: any[]) => void): BindingHydrator;
+    callback(fn: (element: Element, ...data: any[]) => void): BindingHydrator;
+}
+
+export declare function useCache(fn: TemplateBuilder): CachedTemplateFunction;

package/types/validator.ts

@@ -0,0 +1,66 @@
+import {ObservableArray, ObservableChecker, ObservableItem, ObservableObject} from "./observable";
+import { ValidChild } from "./elements";
+import { NDElement } from "./nd-element";
+
+export type ValidChildren = ValidChild | ValidChild[];
+
+/**
+ * Validator utility class with type guards
+ */
+declare const Validator: {
+    isObservable(value: any): value is ObservableItem;
+
+    isProxy(value: any): value is ObservableObject<any>;
+
+    isObservableChecker(value: any): value is ObservableChecker;
+
+    isTemplateBinding(value: any): boolean;
+
+    isObservableWhenResult(value: any): boolean;
+
+    isArrayObservable(value: any): value is ObservableArray<any>;
+
+    isObservableOrProxy(value: any): value is ObservableItem | ObservableObject<any>;
+
+    isAnchor(value: any): boolean;
+
+    isArray(value: any): value is Array<any>;
+
+    isString(value: any): value is string;
+
+    isNumber(value: any): value is number;
+
+    isBoolean(value: any): value is boolean;
+
+    isFunction(value: any): value is Function;
+
+    isAsyncFunction(value: any): value is (...args: any[]) => Promise<any>;
+
+    isObject(value: any): value is object;
+
+    isJson(value: any): value is Record<string, any>;
+
+    isElement(value: any): value is HTMLElement | DocumentFragment | Text;
+
+    isFragment(value: any): value is DocumentFragment;
+
+    isStringOrObservable(value: any): value is string | ObservableItem<string>;
+
+    isValidChild(child: any): child is ValidChild;
+
+    isNDElement(child: any): child is NDElement;
+
+    isValidChildren(children: any): children is ValidChildren;
+
+    validateChildren(children: any): ValidChildren;
+
+    containsObservables(data: any): boolean;
+
+    containsObservableReference(data: any): data is string;
+
+    validateAttributes(attributes: any): Record<string, any> | null | undefined;
+
+    validateEventCallback(callback: any): asserts callback is Function;
+};
+
+export { Validator };

package/ui.js

@@ -0,0 +1 @@
+export * from './src/ui';

package/utils.d.ts

@@ -0,0 +1,4 @@
+
+export * from './types/native-fetch';
+export * from './types/service';
+export * as filters from './types/filters/index';

package/utils.js

@@ -0,0 +1,12 @@
+import NativeFetch from "./src/fetch/NativeFetch";
+import * as Cache from "./src/core/utils/cache";
+import * as filters from "./src/core/utils/filters/index";
+import {classPropertyAccumulator, cssPropertyAccumulator} from "./src/core/utils/property-accumulator";
+
+export {
+    NativeFetch,
+    Cache,
+    filters,
+    classPropertyAccumulator,
+    cssPropertyAccumulator
+};