ivue 0.0.32 → 0.1.0

package/dist/src/ivue.d.ts

@@ -0,0 +1,35 @@
+import { type EffectScope } from 'vue';
+import type { IVue, IVueToRefsObj, AnyClass, InferredArgs, Getters, Computeds } from "./types/core";
+/**
+ * Create ivue instance from class constructor.
+ *
+ * @param className
+ * @param args
+ * @returns @see IVue<T>
+ */
+export declare function ivue<T extends AnyClass>(className: T, ...args: InferredArgs<T>): IVue<T>;
+/**
+ * Create ivue instance from an object.
+ *
+ * @param obj
+ * @returns
+ */
+export declare function iobj<T extends object>(obj: T): T & IVueToRefsObj<T>;
+/**
+ * Pure VueJS Reactive Observable Class-based Architecture System.
+ *
+ * @param vue
+ * @param getters
+ * @param args Arguments are available when used via ivue(obj, ...args)
+ */
+export declare function ivueTransform(vue: any, getters: Getters, computeds: Computeds, scope: EffectScope, ...args: undefined[]): any;
+/**
+ * Convert reactive to refs.
+ *
+ * @param vue @see IVue
+ * @param getters @see Getters
+ * @param computeds @see Computeds
+ * @param scope @see EffectScope
+ * @returns
+ */
+export declare function ivueToRefs<T extends AnyClass>(vue: IVue<T>, getters: Getters, computeds: Computeds, scope: EffectScope): (...props: string[]) => IVue<T>;

package/dist/src/kernel.d.ts

@@ -0,0 +1,182 @@
+import { type EffectScope } from 'vue';
+import type { MappingScope, MappingType, IVue, AnyClass, InferredArgs } from './types/core';
+/**
+ * Kernel Mapping.
+ */
+export declare class Mapping {
+    from: any;
+    /**
+     * Construct mapping, by default set 'to'
+     * to equal 'from' binding, to
+     * support auto-binding.
+     *
+     * @param from mapping pointer
+     */
+    constructor(from: any);
+    /**
+     * Resolves mapping to this value.
+     */
+    to: any;
+    /**
+     * Scope: singleton | transient
+     */
+    scope: MappingScope;
+    /**
+     * Mapping type: generic | ivue | ...
+     */
+    type: MappingType;
+    /**
+     * Mapping initializer method.
+     */
+    onInit: typeof onInit;
+}
+/**
+ * Kernel - ivue IOC Container.
+ *
+ * [IOC] Inversion of Control.
+ * Enables memory and object instance state management.
+ *
+ * Allows creation and storage of singletons and trasients.
+ * Allows for interceptable class architecture.
+ *
+ * Converts clases to ivue reactive instances automatically.
+ *
+ * Smart garbage disposal mechanism allows to keep
+ * the App memory low making it more effiecient.
+ */
+export declare class Kernel {
+    /**
+     * Transiet mappings storage.
+     */
+    transients: WeakMap<object, any>;
+    /**
+     * Singleton mappings storage.
+     */
+    singletons: WeakMap<object, any>;
+    /**
+     * Singleton instances storage.
+     */
+    instances: WeakMap<object, any>;
+    /**
+     * Subscribers
+     */
+    subscribers: WeakMap<AnyClass, number>;
+    /**
+     * Vue EffectScopes for garbage collection.
+     */
+    effectScopes: WeakMap<AnyClass, EffectScope>;
+    /**
+     * Current mapping being set.
+     */
+    current: Mapping;
+    /**
+     * Set mapping to bind from this value.
+     *
+     * @param from mapping pointer
+     * @returns this
+     */
+    bind(from: any): this;
+    /**
+     * Set mapping to resolve the binding to the value of to param.
+     *
+     * @param to resolve mapping to this value
+     * @returns this
+     */
+    to(to: any): this;
+    /**
+     * Set binding to singleton scope.
+     *
+     * @returns this
+     */
+    singleton(): this;
+    /**
+     * Set binding to transient scope.
+     *
+     * @returns this
+     */
+    transient(): this;
+    /**
+     * Set mapping type.
+     *
+     * @param value type of mapping
+     * @returns this
+     */
+    type(value: any): this;
+    /**
+     * Set preset ivue initializer callback.
+     *
+     * @returns this
+     */
+    ivue(): this;
+    /**
+     * Set mapping initializer callback method.
+     *
+     * @param callback Initializer callback method
+     * @returns this
+     */
+    onInit(callback: any): this;
+    /**
+     * Get a singleton instance declared in the container.
+     *
+     * @param className
+     * @param args
+     */
+    get<T extends AnyClass>(className: T, ...args: InferredArgs<T>): InstanceType<T>;
+    /**
+     * Make a transient instance based on container definition.
+     *
+     * @param className
+     * @param args
+     */
+    make<T extends AnyClass>(className: T, ...args: InferredArgs<T>): InstanceType<T>;
+    /**
+     * Initialize ivue singleton instance.
+     *
+     * @param className Class constructor
+     * @param args Class constructor arguments
+     * @returns @see IVue
+     */
+    use<T extends AnyClass>(className: T, ...args: InferredArgs<T>): IVue<T>;
+    /**
+     * Initialize ivue transient instance.
+     *
+     * @param className Class constructor
+     * @param args Class constructor arguments
+     * @returns @see IVue
+     */
+    init<T extends AnyClass>(className: T, ...args: InferredArgs<T>): IVue<T>;
+}
+/**
+ * Any class initializer callback for Kernel Mapping.
+ *
+ * @param mapping @see Mapping
+ * @param args
+ * @returns
+ */
+export declare function onInit<T extends AnyClass>(mapping: Mapping, ...args: InferredArgs<T>): any;
+/**
+ * Activation method to use with Inversify IOC library.
+ *
+ * @param ctx
+ * @param obj
+ * @param args
+ */
+export declare function ivueInversify(ctx: any, obj: any, ...args: any): any;
+/**
+ * Kernel API exported procedural shortcuts.
+ */
+/**
+ * Kernel instance kernel & .bind method
+ */
+export declare const kernel: Kernel;
+export declare const bind: any;
+/**
+ * Kernel container getters for plain JavaScript classes.
+ */
+export declare const get: any;
+export declare const make: any;
+/**
+ * Kernel container getters for ivue reactive JavaScript classes.
+ */
+export declare const use: any;
+export declare const init: any;

package/dist/src/traits/UseCapsule.d.ts

@@ -0,0 +1,9 @@
+import type { AnyClass } from '../types/core';
+export declare class UseCapsule {
+    $: InstanceType<this['capsule']>;
+    capsule: AnyClass | any;
+    useCapsule(args?: any): void;
+    initCapsule(args?: any): void;
+    getCapsule(args?: any): void;
+    makeCapsule(args?: any): void;
+}

package/dist/src/traits/UseEmit.d.ts

@@ -0,0 +1,3 @@
+export declare class UseEmit {
+    $emit: Function;
+}

package/dist/src/traits/UseInstance.d.ts

@@ -0,0 +1,6 @@
+import type { Class } from '../types/core';
+export declare function useInstance(mainClass: Class, self: UseInstance | any): void;
+export declare class UseInstance {
+    get $instance(): import("vue").ComponentInternalInstance;
+    constructor(mainClass: Class);
+}

package/dist/src/traits/UseMounting.d.ts

@@ -0,0 +1,11 @@
+import { type Class } from '../types/core';
+import { onMounted, onUnmounted, onBeforeMount, onBeforeUnmount } from 'vue';
+export declare function useMounting(mainClass: Class, obj: UseMounting | any): void;
+/** Make a class useMounting to a Vue component */
+export declare class UseMounting {
+    constructor(mainClass: Class);
+    beforeMount?: ReturnType<typeof onBeforeMount>;
+    mounted?: ReturnType<typeof onMounted>;
+    beforeUnmount?: ReturnType<typeof onBeforeUnmount>;
+    unmounted?: ReturnType<typeof onUnmounted>;
+}

package/dist/src/traits/UseRefs.d.ts

@@ -0,0 +1,8 @@
+import type { Class } from '../types/core';
+export declare function useRefs(mainClass: Class, obj: any): void;
+export declare class UseRefs {
+    get $refs(): {
+        [x: string]: unknown;
+    };
+    constructor(mainClass: Class);
+}

package/dist/src/traits/UseRoute.d.ts

@@ -0,0 +1,3 @@
+export declare class UseRoute {
+    get route(): any;
+}

package/dist/src/traits/UseRouter.d.ts

@@ -0,0 +1,3 @@
+export declare class UseRouter {
+    get router(): any;
+}

package/dist/src/traits/UseRouting.d.ts

@@ -0,0 +1,6 @@
+import { UseRouter } from './UseRouter';
+import { UseRoute } from './UseRoute';
+export declare class UseRouting {
+}
+export interface UseRouting extends UseRouter, UseRoute {
+}

package/dist/src/traits/UseTick.d.ts

@@ -0,0 +1,4 @@
+import { nextTick } from 'vue';
+export declare class UseTick {
+    $nextTick: typeof nextTick;
+}

package/dist/src/traits/UseVue.d.ts

@@ -0,0 +1,13 @@
+import type { Class } from '../types/core';
+import { UseMounting } from './UseMounting';
+import { UseRouting } from './UseRouting';
+import { UseRefs } from './UseRefs';
+import { UseEmit } from './UseEmit';
+import { UseTick } from './UseTick';
+import { UseInstance } from './UseInstance';
+export declare function useVue(mainClass: Class, obj: UseVue | any): void;
+export declare class UseVue {
+    constructor(mainClass: Class);
+}
+export interface UseVue extends UseRouting, UseMounting, UseEmit, UseTick, UseRefs, UseInstance {
+}

package/dist/src/types/core.d.ts

@@ -0,0 +1,46 @@
+import type { Mapping } from '../kernel';
+import type { ComputedRef } from 'vue';
+export type AnyClass = abstract new (...args: any) => any;
+export type Class = {
+    behavior?: any;
+    new (...args: any[]): any;
+    [x: string | symbol]: any;
+};
+export type IVue<T extends AnyClass> = InstanceType<T> & IVueToRefs<T>;
+/**
+ * @see ivueTransform
+ */
+export interface IVueToRefs<T extends AnyClass> {
+    toRefs: (...args: any) => InstanceType<T>;
+}
+export interface IVueToRefsObj<T extends object> {
+    toRefs: (...args: any) => T;
+}
+export type MappingScope = 'singleton' | 'transient';
+export type MappingType = 'generic' | 'ivue' | any;
+export type InferredArgs<T> = T extends {
+    new (...args: infer P): any;
+} ? P : never[];
+export type Getters = Map<string | symbol | number, PropertyDescriptor>;
+export interface Intercept {
+    return: any;
+    mapping: Mapping;
+    name?: string;
+    self: any;
+    args: any;
+}
+export type InterceptOptions = {
+    top: boolean;
+    scoped: boolean;
+};
+export type InterceptFn = (intercept: Intercept, self: Object, prop: string) => void | true;
+export type InterceptsMap = {
+    before: Map<Function | Class, InterceptFn[]>;
+    after: Map<Function | Class, InterceptFn[]>;
+};
+export type InterceptAttachTo = Function | [Class, Function];
+export type InterceptsFns = InterceptFn[] | undefined | any;
+export type Null<T> = T | null;
+export type AnyObj = Record<string | number | symbol, any>;
+export type Params<T extends (...args: any) => any> = Parameters<T>;
+export type Computeds = Record<string | symbol | number, ComputedRef>;

package/dist/src/utils/dispose-garbage.d.ts

@@ -0,0 +1,12 @@
+import type { AnyClass, IVue } from "..";
+/**
+ * Advanced garbage disposal for complete memory control.
+ * Disposes an internal object that is under the vue reactive proxy.
+ * To expose the raw property, toRaw(vue) method is used
+ * to retrieve the original object.
+ *
+ * @param vue ivue instance
+ * @param getters @see Getters
+ * @param name string
+ */
+export declare const disposeGarbage: <T extends AnyClass>(vue: any) => void;

package/dist/src/utils/extend.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Advanced deep merge of two or more objects.
+ * Merges sources into target iterating from left to right.
+ * Supports circular references and promises.
+ * Merges and modifies the target object.
+ * Only simple objects can extend the target, yet the
+ * target can be anything, even a class object.
+ *
+ * @param target object
+ * @param sources array
+ */
+export declare function extend(target: any, ...sources: any[]): any;

package/dist/src/utils/getters.d.ts

@@ -0,0 +1,21 @@
+import type { Getters } from '../types/core';
+/**
+ * Store all getters for each class prototype processed by getPrototypeGetters.
+ * @see getPrototypeGetters
+ */
+export declare const gettersMap: Map<any, any>;
+/**
+ * Get getters of a class prototype as a map.
+ *
+ * @param proto
+ * @return Getters
+ */
+export declare function getPrototypeGetters(proto: object | null): any;
+/**
+ * Get getters of a class instance and the total number of them.
+ * @param instance Object instance
+ * @returns Getter descriptors
+ */
+export declare function getInstanceGetters(instance: {
+    [x: string]: any;
+}): Getters;

package/dist/src/utils/index.d.ts

@@ -0,0 +1,7 @@
+import { raw, unraw } from './raw';
+import { extend } from './extend';
+import { Traits } from './traits';
+import { getPrototypeGetters, getInstanceGetters } from './getters';
+import { safeClassName } from './safe-class-name';
+import { pre } from './pre';
+export { raw, unraw, extend, Traits, getPrototypeGetters, getInstanceGetters, safeClassName, pre };

package/dist/src/utils/is.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Determine if the value is a true Object.
+ *
+ * @param v any value
+ * @returns boolean
+ */
+export declare function isObject(v: any): boolean;
+/**
+ * Determine if the value is a Promise.
+ *
+ * @param v any value
+ * @returns boolean
+ */
+export declare function isPromise(v: any): boolean;

package/dist/src/utils/pre.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Pretty print an object that can contain circular references.
+ *
+ * @param v      object to print
+ * @param spaces number of spaces for tabs
+ * @returns      pretty string
+ * @source       https://stackoverflow.com/a/48254637
+ */
+export declare function pre(v: any, spaces?: number): string;

package/dist/src/utils/raw.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Convert object back to Vue reactive.
+ *
+ * @param obj
+ */
+export declare function unraw(obj: any): void;
+/**
+ * Alias for Vue markRaw() function.
+ *
+ * @param obj
+ */
+export declare function raw(obj: any): any;

package/dist/src/utils/safe-class-name.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Convert class name, symbol to string.
+ *
+ * @param className
+ * @returns
+ */
+export declare function safeClassName(className: any): string;

package/dist/src/utils/traits.d.ts

@@ -0,0 +1,41 @@
+import type { Class } from '../types/core';
+/**
+ * Traits architecture that supports methods, properties, getters and setters.
+ *
+ * Traits override each other, while traits can set new props onto
+ * the main prototype, they cannot override the main prototypes'
+ * props if the main prototype had them already initially.
+ *
+ * Traits override each other, left most traits having higher priority, matching
+ * TypeScript's interface `interface Class extends Trait1, Trait2, Trait3 {}`
+ * architecture, enabling us to have full TypeScript & IDE support:
+ *
+ * Example:
+ * ```ts
+ * class MainClass {}
+ *
+ * class Trait1 {
+ *   get prop () { return 3 }
+ * }
+ *
+ * class Trait2 {
+ *   get prop () { return 2 }
+ * }
+ *
+ * class Trait3 {
+ *   get prop () { return 3 }
+ * }
+ *
+ * Traits(MainClass, [Trait1, Trait2, Trait3])
+ * export interface MainClass extends Trait1, Trait2, Trait3 {}
+ * ```
+ *
+ * Trait1 props will override Traits2 & Traits3 properties,
+ * but will not override MainClass properties if set.
+ *
+ * Inspired by TypeScript docs: https://www.typescriptlang.org/docs/handbook/mixins.html#alternative-pattern
+ *
+ * @param main
+ * @param traits
+ */
+export declare function Traits(main: Class, traits: Class[]): void;

package/env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <link rel="icon" href="/favicon.ico">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Vite App</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="./demo/main.ts"></script>
+  </body>
+</html>