@base-framework/base 3.0.79 → 3.0.80

package/dist/types/base.d.ts

@@ -0,0 +1,25 @@
+import { Ajax } from './modules/ajax/ajax.js';
+import { Arrays } from './shared/arrays.js';
+import { Atom } from './modules/atom/atom.js';
+import { Builder } from './modules/layout/builder.js';
+import { Component } from './modules/component/component.js';
+import { Data } from './modules/data/data.js';
+import { DataTracker } from './main/data-tracker/data-tracker.js';
+import { DateTime } from "./modules/date/date-time.js";
+import { Directives } from './modules/layout/directives/directives.js';
+import { Dom } from './shared/dom.js';
+import { Html } from './modules/html/html.js';
+import { Import } from './modules/import/import.js';
+import { Jot } from './modules/component/jot.js';
+import { Model } from './modules/data/data.js';
+import { NavLink } from './modules/router/router.js';
+import { Objects } from './shared/objects.js';
+import { SimpleData } from './modules/data/data.js';
+import { StateTracker as State } from './modules/state/state-tracker.js';
+import { Strings } from './shared/strings.js';
+import { Types } from './shared/types.js';
+import { Unit } from './modules/component/unit.js';
+import { base } from './main/base.js';
+import { dataBinder } from './modules/data-binder/data-binder.js';
+import { router } from './modules/router/router.js';
+export { Ajax, Arrays, Atom, Builder, Component, Data, DataTracker, DateTime, Directives, Dom, Html, Import, Jot, Model, NavLink, Objects, SimpleData, State, Strings, Types, Unit, base, dataBinder, router };

package/dist/types/main/base.d.ts

@@ -0,0 +1,94 @@
+/**
+ * This is the instance of base that all modules will use.
+ *
+ * @global
+ */
+export const base: Base;
+/**
+ * Base
+ *
+ * This is the base framework.
+ *
+ * @class
+ */
+declare class Base {
+    /**
+     * @member {string} version
+     */
+    version: string;
+    /**
+     * @member {array} errors
+     */
+    errors: any[];
+    /**
+     * @member {object} dataTracker
+     */
+    dataTracker: typeof DataTracker;
+    /**
+     * this will augement the base framework with new functionality.
+     *
+     * @param {object} methods The new methods to add.
+     * @returns {object} An instance of base.
+     */
+    augment(methods: object): object;
+    /**
+     * This will override a method function with a new function.
+     *
+     * @param {object} obj The object being modified.
+     * @param {string} methodName the method name being overriden.
+     * @param {function} overrideMethod The new function to call.
+     * @param {array} args The args to pass to the first function call.
+     * @returns {*} The results of the function being called.
+     */
+    override(obj: object, methodName: string, overrideMethod: Function, args: any[]): any;
+    /**
+     * This will get the last error.
+     *
+     * @returns {(object|boolean)} The last error or false.
+     */
+    getLastError(): (object | boolean);
+    /**
+     * This will add an error.
+     *
+     * @param {object} err
+     * @returns {void}
+     */
+    addError(err: object): void;
+    /**
+     * This will get the value from a property on an object.
+     *
+     * @param {object} obj
+     * @param {string} property
+     * @param {*} [defaultText] A value if no value is set.
+     * @returns {string}
+     */
+    getProperty(obj: object, property: string, defaultText?: any): string;
+    /**
+     * This will create a callBack.
+     *
+     * @param {object} obj
+     * @param {function} method
+     * @param {array} [argArray] Default args to pass.
+     * @param {boolean} [addArgs] Set to add merge args from the
+     * curried function.
+     * @returns {function|boolean} The callBack function or false.
+     */
+    createCallBack(obj: object, method: Function, argArray?: any[], addArgs?: boolean): Function | boolean;
+    /**
+     * This will bind scope to a method.
+     *
+     * @param {object} obj
+     * @param {function} method
+     * @returns {function}
+     */
+    bind(obj: object, method: Function): Function;
+    /**
+     * This will return the base prototype to allow the module
+     * to be added to base as a module.
+     *
+     * @returns {object} the base prototype.
+     */
+    extend: Base;
+}
+import { DataTracker } from './data-tracker/data-tracker.js';
+export {};

package/dist/types/main/data-tracker/data-tracker.d.ts

@@ -0,0 +1,93 @@
+/**
+ * DataTracker
+ *
+ * This will add data tracking for objects. The DataTracker is
+ * a single point where any data can be tracked to an object
+ * or element. Modules can register types to store their own
+ * data that can allow the data to be removed when the element
+ * is removed.
+ *
+ * @class
+ */
+export class DataTracker {
+    /**
+     * @private
+     * @static
+     * @member {Map} trackers This is an object that stores all tracker
+     * objects by tracking id.
+     */
+    private static trackers;
+    /**
+     * @private
+     * @static
+     * @member {number} trackingCount
+     */
+    private static trackingCount;
+    /**
+     * This will add a new type to the data tracker.
+     *
+     * @public
+     * @param {string} type The new type.
+     * @param {function} callBack The callBack to help clean
+     * up data when removed.
+     * @returns {void}
+     */
+    public static addType(type: string, callBack: Function): void;
+    /**
+     * This will remove a type from the data tracker.
+     *
+     * @param {string} type
+     * @returns {void}
+     */
+    static removeType(type: string): void;
+    /**
+     * This will get the object tracking id or set it if
+     * not set.
+     *
+     * @param {object} obj
+     * @returns {string}
+     */
+    static getTrackingId(obj: object): string;
+    /**
+     * This will add data to an object.
+     *
+     * @param {object} obj
+     * @param {string} type The type name.
+     * @param {*} data The data to track.
+     * @returns {void}
+     */
+    static add(obj: object, type: string, data: any): void;
+    /**
+     * This will get the data from a type or the tracker object
+     * if type is not set.
+     *
+     * @param {object} obj
+     * @param {string} [type]
+     * @returns {*}
+     */
+    static get(obj: object, type?: string): any;
+    /**
+     * This will get the tracker or create a new tracker
+     * if no tracker is set.
+     *
+     * @param {string} id
+     * @returns {object} The tracker.
+     */
+    static find(id: string): object;
+    /**
+     * This will check if an object is empty.
+     *
+     * @param {object} obj
+     * @returns {boolean}
+     */
+    static isEmpty(obj: object): boolean;
+    /**
+     * This will remove a type or all data for an object if
+     * no type is set.
+     *
+     * @param {object} obj
+     * @param {string} [type]
+     * @returns {void}
+     */
+    static remove(obj: object, type?: string): void;
+}

package/dist/types/main/data-tracker/tracker-types.d.ts

@@ -0,0 +1,23 @@
+export namespace TrackerTypes {
+    let types: {};
+    /**
+     * This will add a type.
+     * @param {string} type
+     * @param {function} callBack The function to call when an object
+     * is having the type removed.
+     * @returns {void}
+     */
+    function add(type: string, callBack: Function): void;
+    /**
+     * This will get a type or return false.
+     * @param {string} type
+     * @returns {(Function|false)} The callBack or false.
+     */
+    function get(type: string): false | Function;
+    /**
+     * This will remove a type.
+     * @param {string} type
+     * @returns {void}
+     */
+    function remove(type: string): void;
+}

package/dist/types/main/data-tracker/tracker.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Tracker
+ *
+ * This will create a tracker for an object that will
+ * store each type added and the data stored to
+ * each type.
+ *
+ * @class
+ */
+export class Tracker {
+    /**
+     * @member {Map} types
+     */
+    types: Map<any, any>;
+    /**
+     * This will add data to a type.
+     *
+     * @public
+     * @param {string} addingType The type of data.
+     * @param {*} data The data to store
+     * @returns {void}
+     */
+    public add(addingType: string, data: any): void;
+    /**
+     * This will get all the data stored to a data type.
+     * @param {string} type
+     * @returns {*} the data or false.
+     */
+    get(type: string): any;
+    /**
+     * This will call the callBack with the data.
+     *
+     * @private
+     * @param {function} callBack
+     * @param {*} data
+     * @returns {void}
+     */
+    private removeByCallBack;
+    /**
+     * This will remove the data by type.
+     *
+     * @private
+     * @param {string} removingType
+     * @returns {void}
+     */
+    private removeType;
+    /**
+     * This will remove the data by type or all if no type is
+     * set.
+     *
+     * @public
+     * @param {string} [type]
+     * @returns {void}
+     */
+    public remove(type?: string): void;
+}

package/dist/types/main/equals.d.ts

@@ -0,0 +1 @@
+export function equals(option1: any, option2: any): boolean;

package/dist/types/main/events/event-methods.d.ts

@@ -0,0 +1,124 @@
+export namespace EventMethods {
+    export { Events as events };
+    /**
+     * This will add an event to an object.
+     *
+     * @param {string} event The event name.
+     * @param {object} obj
+     * @param {function} fn
+     * @param {boolean} [capture]
+     * @returns {object}
+     */
+    export function addListener(event: string, obj: any, fn: Function, capture?: boolean): any;
+    /**
+     * This will add an event to an object.
+     *
+     * @param {string} event The event name.
+     * @param {object} obj
+     * @param {function} fn
+     * @param {boolean} [capture]
+     * @returns {object}
+     */
+    export function on(event: string, obj: any, fn: Function, capture?: boolean): any;
+    /**
+     * This will remove an event from an object.
+     *
+     * @param {string} event The event name.
+     * @param {object} obj
+     * @param {function} fn
+     * @param {boolean} [capture]
+     * @returns {object}
+     */
+    export function off(event: string, obj: any, fn: Function, capture?: boolean): any;
+    /**
+     * This will remove an event from an object.
+     *
+     * @param {string} event The event name.
+     * @param {object} obj
+     * @param {function} fn
+     * @param {boolean} [capture]
+     * @returns {object}
+     */
+    export function removeListener(event: string, obj: any, fn: Function, capture?: boolean): any;
+    /**
+     * This will create a custom event.
+     *
+     * @protected
+     * @param {object} event
+     * @param {string} eventType
+     * @param {object} [settings]
+     * @param {object} [params]
+     * @returns {object}
+     */
+    export function _createEvent(event: any, eventType: string, settings?: any, params?: any): any;
+    /**
+     * This will create a custom event. This supports html, mouse,
+     * and customevents.
+     *
+     * @param {string} event
+     * @param {object} obj
+     * @param {object} [options]
+     * @param {object} [params]
+     * @returns {object}
+     */
+    export function createEvent(event: string, obj: any, options?: any, params?: any): any;
+    /**
+     * This will get thetype of an event.
+     *
+     * @protected
+     * @param {string} event
+     * @returns {string}
+     */
+    export function _getEventType(event: string): string;
+    /**
+     * This will trigger an event.
+     *
+     * @param {string|object} event
+     * @param {object} obj
+     * @param {object} [params]
+     * @returns {object}
+     */
+    export function trigger(event: any, obj: any, params?: any): any;
+    export let mouseWheelEventType: any;
+    /**
+     * This will get the system mouse event.
+     *
+     * @protected
+     * @returns {string}
+     */
+    export function getWheelEventType(): string;
+    /**
+     * This will add a mouse event to  an object.
+     *
+     * @param {function} callBackFn
+     * @param {object} [obj]
+     * @param {boolean} [cancelDefault]
+     * @param {boolean} [capture]
+     * @returns {object} base object.
+     */
+    export function onMouseWheel(callBackFn: Function, obj?: any, cancelDefault?: boolean, capture?: boolean): any;
+    /**
+     * This will remove a mouse event
+     *
+     * @param {function} callBackFn
+     * @param {object} [obj]
+     * @param {boolean} [capture]
+     * @returns {object} base object.
+     */
+    export function offMouseWheel(callBackFn: Function, obj?: any, capture?: boolean): any;
+    /**
+     * This will prevent default on an event.
+     *
+     * @param {object} e
+     * @returns {object} base object.
+     */
+    export function preventDefault(e: any): any;
+    /**
+     * This will stop an event from propigating.
+     *
+     * @param {object} e
+     * @returns {object} base object.
+     */
+    export function stopPropagation(e: any): any;
+}
+import { Events } from './events.js';

package/dist/types/main/events/events.d.ts

@@ -0,0 +1,208 @@
+export namespace Events {
+    /**
+     * This will get the events on an element.
+     *
+     * @param {object} obj
+     * @returns {array}
+     */
+    function getEvents(obj: any): any[];
+    /**
+     * This will create an object to use with the dataTracker.
+     *
+     * @param {string} event The event name.
+     * @param {object} obj
+     * @param {function} fn
+     * @param {boolean} [capture]
+     * @param {boolean} [swapped]
+     * @param {function} [originalFn]
+     * @returns {object}
+     */
+    function create(event: string, obj: any, fn: Function, capture?: boolean, swapped?: boolean, originalFn?: Function): any;
+    /**
+     * This will add an event to an object.
+     *
+     * @param {string|array} event The event name.
+     * @param {object} obj
+     * @param {function} fn
+     * @param {boolean} [capture]
+     * @returns {object} The events object.
+     */
+    function on(event: string | any[], obj: any, fn: Function, capture?: boolean): any;
+    /**
+     * This will remove an event from an object.
+     *
+     * @param {string|array} event The event name.
+     * @param {object} obj
+     * @param {function} fn
+     * @param {boolean} [capture]
+     * @returns {object} The events object.
+     */
+    function off(event: string | any[], obj: any, fn: Function, capture?: boolean): any;
+    /**
+     * This will add an event to an object.
+     *
+     * @param {string} event The event name.
+     * @param {object} obj
+     * @param {function} fn
+     * @param {object|boolean} [capture]
+     * @param {boolean} [swapped]
+     * @param {function} [originalFn]
+     */
+    function add(event: string, obj: any, fn: Function, capture?: any, swapped?: boolean, originalFn?: Function): {
+        /**
+         * This will get the events on an element.
+         *
+         * @param {object} obj
+         * @returns {array}
+         */
+        getEvents(obj: any): any[];
+        /**
+         * This will create an object to use with the dataTracker.
+         *
+         * @param {string} event The event name.
+         * @param {object} obj
+         * @param {function} fn
+         * @param {boolean} [capture]
+         * @param {boolean} [swapped]
+         * @param {function} [originalFn]
+         * @returns {object}
+         */
+        create(event: string, obj: any, fn: Function, capture?: boolean, swapped?: boolean, originalFn?: Function): any;
+        /**
+         * This will add an event to an object.
+         *
+         * @param {string|array} event The event name.
+         * @param {object} obj
+         * @param {function} fn
+         * @param {boolean} [capture]
+         * @returns {object} The events object.
+         */
+        on(event: string | any[], obj: any, fn: Function, capture?: boolean): any;
+        /**
+         * This will remove an event from an object.
+         *
+         * @param {string|array} event The event name.
+         * @param {object} obj
+         * @param {function} fn
+         * @param {boolean} [capture]
+         * @returns {object} The events object.
+         */
+        off(event: string | any[], obj: any, fn: Function, capture?: boolean): any;
+        add(event: string, obj: any, fn: Function, capture?: any, swapped?: boolean, originalFn?: Function): any;
+        /**
+         * This will remove an event from an object.
+         *
+         * @param {string} event The event name.
+         * @param {object} obj
+         * @param {function} fn
+         * @param {object|boolean} [capture]
+         * @returns {object} a reference to the event object.
+         */
+        remove(event: string, obj: any, fn: Function, capture?: any): any;
+        /**
+         * This will remove an event listener.
+         * @param {object} listener
+         * @returns {object} a reference to the event object.
+         */
+        removeEvent(listener: any): any;
+        /**
+         * This will search for an event.
+         *
+         * @protected
+         * @param {string} event The event name.
+         * @param {object} obj
+         * @param {function} fn
+         * @param {boolean} [capture]
+         * @returns {object|boolean}
+         */
+        getEvent(event: string, obj: any, fn: Function, capture?: boolean): any;
+        /**
+         * This will search for an event from the object events.
+         *
+         * @param {object} eventObj
+         * @param {array} events
+         * @returns {object|boolean}
+         */
+        search(eventObj: any, events: any[]): any;
+        /**
+         * This will remove all events on an object.
+         *
+         * @param {object} obj
+         * @returns {object} a reference to the events object.
+         */
+        removeEvents(obj: any): any;
+        /**
+         * @member {array} swap The swappable events.
+         */
+        swap: string[];
+        /**
+         * This will a event type to the swappable array.
+         *
+         * @param {string} type
+         */
+        addSwapped(type: string): void;
+        /**
+         * This will check if an event is swappable.
+         *
+         * @param {string} event
+         * @returns {boolean}
+         */
+        isSwappable(event: string): boolean;
+    };
+    /**
+     * This will remove an event from an object.
+     *
+     * @param {string} event The event name.
+     * @param {object} obj
+     * @param {function} fn
+     * @param {object|boolean} [capture]
+     * @returns {object} a reference to the event object.
+     */
+    function remove(event: string, obj: any, fn: Function, capture?: any): any;
+    /**
+     * This will remove an event listener.
+     * @param {object} listener
+     * @returns {object} a reference to the event object.
+     */
+    function removeEvent(listener: any): any;
+    /**
+     * This will search for an event.
+     *
+     * @protected
+     * @param {string} event The event name.
+     * @param {object} obj
+     * @param {function} fn
+     * @param {boolean} [capture]
+     * @returns {object|boolean}
+     */
+    function getEvent(event: string, obj: any, fn: Function, capture?: boolean): any;
+    /**
+     * This will search for an event from the object events.
+     *
+     * @param {object} eventObj
+     * @param {array} events
+     * @returns {object|boolean}
+     */
+    function search(eventObj: any, events: any[]): any;
+    /**
+     * This will remove all events on an object.
+     *
+     * @param {object} obj
+     * @returns {object} a reference to the events object.
+     */
+    function removeEvents(obj: any): any;
+    let swap: string[];
+    /**
+     * This will a event type to the swappable array.
+     *
+     * @param {string} type
+     */
+    function addSwapped(type: string): void;
+    /**
+     * This will check if an event is swappable.
+     *
+     * @param {string} event
+     * @returns {boolean}
+     */
+    function isSwappable(event: string): boolean;
+}