@razaman2/reactive-view 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 razamvmt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# reactive-view

package/dist/index.d.mts

@@ -0,0 +1,176 @@
+import * as vue from 'vue';
+import { SetupContext, ComponentPublicInstance, UnwrapRef } from 'vue';
+
+type SubscriptionItem = {
+    name: string;
+    handler: Function;
+    data?: any;
+};
+declare class Subscription {
+    private subscriptions;
+    private data;
+    static create(): Subscription;
+    subscribe(name: string, handler: Function, data?: any): Subscription;
+    replace(name: string, handler: Function, data?: any): Subscription;
+    unsubscribe(subscription?: string): Subscription;
+    unsubscribe(subscriptions?: Array<string>): Subscription;
+    size(): number;
+    hasSubscription(name: string): boolean;
+    private remove;
+    private find;
+    private isNameAvailable;
+    registrations(): Array<SubscriptionItem>;
+    get(name: string): SubscriptionItem;
+}
+
+declare const setup: {
+    setup: {
+        type: FunctionConstructor;
+        default: (param1?: {}, param2?: {}) => {};
+    };
+};
+declare const _default$1: {
+    props: {
+        defaultData: {};
+        getDefaultData: {
+            type: FunctionConstructor;
+            default: (data?: {}) => {};
+        };
+        logging: {
+            validator: (logging: unknown) => boolean;
+        };
+        model: {};
+        modelName: {
+            type: StringConstructor;
+            default: string;
+        };
+        notifications: {
+            type: ObjectConstructor;
+        };
+        root: {
+            type: FunctionConstructor;
+        };
+        state: {};
+        subscriptions: {
+            type: ObjectConstructor;
+            default: {
+                addSubscription(name: string, handler?: () => boolean, data?: any): void;
+                replaceSubscription(name: string, handler?: () => boolean, data?: any): void;
+                removeSubscriptions(): void;
+                removeSubscription(name: string): void;
+                hasSubscription(name: string): boolean;
+                subscriptions: any[];
+                subscription: Subscription;
+            };
+        };
+        setup: {
+            type: FunctionConstructor;
+            default: (param1?: {}, param2?: {}) => {};
+        };
+    };
+    setup(props: Record<string, any>, context: SetupContext): ($vue: ComponentPublicInstance & any) => any;
+};
+
+declare const _default: {
+    props: {
+        resolve: {
+            required: boolean;
+        };
+        delay: {
+            type: NumberConstructor;
+            default: number;
+        };
+        timeout: {
+            type: NumberConstructor;
+            default: number;
+        };
+        loading: {
+            default: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>;
+        };
+        options: {
+            type: ObjectConstructor;
+        };
+        error: {
+            required: boolean;
+        };
+        setup: {
+            type: FunctionConstructor;
+            default: (param1?: {}, param2?: {}) => {};
+        };
+    };
+    setup(): ($vue: any) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>;
+};
+
+/**
+ * uppercase the first character of each word in the input string.
+ * @description
+ * (test -> Test), (TEST -> Test), (test test -> Test Test)
+ */
+declare function ucf(string: string): string;
+/**
+ * uppercase the first character of each word that follows a specified token
+ * @description
+ * (test-test -> test-Test), (TEST-TEST -> TEST-Test), (test/test -> test/Test)
+ */
+declare function ucfat(string: string, tokens: Array<string>): string;
+declare function safeRequest(request: {
+    try: () => Promise<any> | any;
+    catch?: ((error: any) => Promise<any> | any) | false;
+    finally?: () => Promise<any> | any;
+    complete?: () => Promise<any> | any;
+    loading?: {
+        status: boolean;
+        message?: string;
+    };
+    message?: string;
+    alternative?: boolean;
+}): Promise<any>;
+declare function getRoot(vue: ComponentPublicInstance): any;
+type PropOptions = {
+    exclude: string | Array<string>;
+    include: Record<string, any>;
+};
+type PropExclusions = Array<string> | string;
+declare function getProps(props: Record<string, any>, exclude: PropExclusions): Record<string, any>;
+declare function getProps(props: Record<string, any>, options: PropOptions): Record<string, any>;
+declare function getDate(timestamp: {
+    toDate: () => Date;
+} | Date, format?: string): string;
+declare function getDate(timestamp: {
+    toDate: () => Date;
+} | Date, options?: {
+    format?: string;
+    timezone?: string;
+}): string;
+declare function getRef(component: ComponentPublicInstance, ref: UnwrapRef<any>): ComponentPublicInstance;
+declare function expose(vue: any, props: Record<string, any>): Record<string, any>;
+declare function getSubscription(): {
+    addSubscription(name: string, handler?: () => boolean, data?: any): void;
+    replaceSubscription(name: string, handler?: () => boolean, data?: any): void;
+    removeSubscriptions(): void;
+    removeSubscription(name: string): void;
+    hasSubscription(name: string): boolean;
+    subscriptions: any[];
+    subscription: Subscription;
+};
+type Accessible = {
+    parent: {
+        self: Record<string | symbol, any>;
+    };
+    self: Record<string | symbol, any>;
+    access?: Function;
+    value?: {
+        parent: {
+            self: Record<string | symbol, any>;
+        };
+        self: Record<string | symbol, any>;
+        access?: Function;
+    };
+};
+declare function access<T extends ComponentPublicInstance & Accessible>($vue?: T): any;
+
+export { _default as AsyncComponent, access, _default$1 as default, expose, getDate, getProps, getRef, getRoot, getSubscription, safeRequest, setup, ucf, ucfat };

package/dist/index.d.ts

@@ -0,0 +1,176 @@
+import * as vue from 'vue';
+import { SetupContext, ComponentPublicInstance, UnwrapRef } from 'vue';
+
+type SubscriptionItem = {
+    name: string;
+    handler: Function;
+    data?: any;
+};
+declare class Subscription {
+    private subscriptions;
+    private data;
+    static create(): Subscription;
+    subscribe(name: string, handler: Function, data?: any): Subscription;
+    replace(name: string, handler: Function, data?: any): Subscription;
+    unsubscribe(subscription?: string): Subscription;
+    unsubscribe(subscriptions?: Array<string>): Subscription;
+    size(): number;
+    hasSubscription(name: string): boolean;
+    private remove;
+    private find;
+    private isNameAvailable;
+    registrations(): Array<SubscriptionItem>;
+    get(name: string): SubscriptionItem;
+}
+
+declare const setup: {
+    setup: {
+        type: FunctionConstructor;
+        default: (param1?: {}, param2?: {}) => {};
+    };
+};
+declare const _default$1: {
+    props: {
+        defaultData: {};
+        getDefaultData: {
+            type: FunctionConstructor;
+            default: (data?: {}) => {};
+        };
+        logging: {
+            validator: (logging: unknown) => boolean;
+        };
+        model: {};
+        modelName: {
+            type: StringConstructor;
+            default: string;
+        };
+        notifications: {
+            type: ObjectConstructor;
+        };
+        root: {
+            type: FunctionConstructor;
+        };
+        state: {};
+        subscriptions: {
+            type: ObjectConstructor;
+            default: {
+                addSubscription(name: string, handler?: () => boolean, data?: any): void;
+                replaceSubscription(name: string, handler?: () => boolean, data?: any): void;
+                removeSubscriptions(): void;
+                removeSubscription(name: string): void;
+                hasSubscription(name: string): boolean;
+                subscriptions: any[];
+                subscription: Subscription;
+            };
+        };
+        setup: {
+            type: FunctionConstructor;
+            default: (param1?: {}, param2?: {}) => {};
+        };
+    };
+    setup(props: Record<string, any>, context: SetupContext): ($vue: ComponentPublicInstance & any) => any;
+};
+
+declare const _default: {
+    props: {
+        resolve: {
+            required: boolean;
+        };
+        delay: {
+            type: NumberConstructor;
+            default: number;
+        };
+        timeout: {
+            type: NumberConstructor;
+            default: number;
+        };
+        loading: {
+            default: vue.VNode<vue.RendererNode, vue.RendererElement, {
+                [key: string]: any;
+            }>;
+        };
+        options: {
+            type: ObjectConstructor;
+        };
+        error: {
+            required: boolean;
+        };
+        setup: {
+            type: FunctionConstructor;
+            default: (param1?: {}, param2?: {}) => {};
+        };
+    };
+    setup(): ($vue: any) => vue.VNode<vue.RendererNode, vue.RendererElement, {
+        [key: string]: any;
+    }>;
+};
+
+/**
+ * uppercase the first character of each word in the input string.
+ * @description
+ * (test -> Test), (TEST -> Test), (test test -> Test Test)
+ */
+declare function ucf(string: string): string;
+/**
+ * uppercase the first character of each word that follows a specified token
+ * @description
+ * (test-test -> test-Test), (TEST-TEST -> TEST-Test), (test/test -> test/Test)
+ */
+declare function ucfat(string: string, tokens: Array<string>): string;
+declare function safeRequest(request: {
+    try: () => Promise<any> | any;
+    catch?: ((error: any) => Promise<any> | any) | false;
+    finally?: () => Promise<any> | any;
+    complete?: () => Promise<any> | any;
+    loading?: {
+        status: boolean;
+        message?: string;
+    };
+    message?: string;
+    alternative?: boolean;
+}): Promise<any>;
+declare function getRoot(vue: ComponentPublicInstance): any;
+type PropOptions = {
+    exclude: string | Array<string>;
+    include: Record<string, any>;
+};
+type PropExclusions = Array<string> | string;
+declare function getProps(props: Record<string, any>, exclude: PropExclusions): Record<string, any>;
+declare function getProps(props: Record<string, any>, options: PropOptions): Record<string, any>;
+declare function getDate(timestamp: {
+    toDate: () => Date;
+} | Date, format?: string): string;
+declare function getDate(timestamp: {
+    toDate: () => Date;
+} | Date, options?: {
+    format?: string;
+    timezone?: string;
+}): string;
+declare function getRef(component: ComponentPublicInstance, ref: UnwrapRef<any>): ComponentPublicInstance;
+declare function expose(vue: any, props: Record<string, any>): Record<string, any>;
+declare function getSubscription(): {
+    addSubscription(name: string, handler?: () => boolean, data?: any): void;
+    replaceSubscription(name: string, handler?: () => boolean, data?: any): void;
+    removeSubscriptions(): void;
+    removeSubscription(name: string): void;
+    hasSubscription(name: string): boolean;
+    subscriptions: any[];
+    subscription: Subscription;
+};
+type Accessible = {
+    parent: {
+        self: Record<string | symbol, any>;
+    };
+    self: Record<string | symbol, any>;
+    access?: Function;
+    value?: {
+        parent: {
+            self: Record<string | symbol, any>;
+        };
+        self: Record<string | symbol, any>;
+        access?: Function;
+    };
+};
+declare function access<T extends ComponentPublicInstance & Accessible>($vue?: T): any;
+
+export { _default as AsyncComponent, access, _default$1 as default, expose, getDate, getProps, getRef, getRoot, getSubscription, safeRequest, setup, ucf, ucfat };