uicore-ts 1.0.1

package/compiledScripts/UICore.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IS_SAFARI = exports.IS_FIREFOX = exports.UICore = void 0;
+const UIObject_1 = require("./UIObject");
+const UIRoute_1 = require("./UIRoute");
+const UIView_1 = require("./UIView");
+const UIViewController_1 = require("./UIViewController");
+require("./UICoreExtensions");
+class UICore extends UIObject_1.UIObject {
+    constructor(rootDivElementID, rootViewControllerClass) {
+        super();
+        this.rootViewController = UIObject_1.nil;
+        this._class = UICore;
+        this.superclass = UIObject_1.UIObject;
+        UICore.RootViewControllerClass = rootViewControllerClass;
+        UICore.main = this;
+        const rootViewElement = document.getElementById(rootDivElementID);
+        const rootView = new UIView_1.UIView(rootDivElementID, rootViewElement);
+        rootView.pausesPointerEvents = UIObject_1.NO; //YES;
+        if (UICore.RootViewControllerClass) {
+            if (!(UICore.RootViewControllerClass.prototype instanceof UIViewController_1.UIViewController) ||
+                UICore.RootViewControllerClass === UIViewController_1.UIViewController) {
+                console.log("Error, UICore.RootViewControllerClass must be a or a subclass of UIViewController, falling back to UIViewController.");
+                UICore.RootViewControllerClass = UIViewController_1.UIViewController;
+            }
+            this.rootViewController = new UICore.RootViewControllerClass(rootView);
+        }
+        else {
+            this.rootViewController = new UIViewController_1.UIViewController(rootView);
+        }
+        this.rootViewController.viewWillAppear();
+        this.rootViewController.viewDidAppear();
+        this.rootViewController.view.addTargetForControlEvent(UIView_1.UIView.controlEvent.PointerUpInside, function (sender, event) {
+            document.activeElement.blur();
+        });
+        const windowDidResize = function () {
+            // Doing layout two times to prevent page scrollbars from confusing the layout
+            this.rootViewController._layoutViewSubviews();
+            UIView_1.UIView.layoutViewsIfNeeded();
+            this.rootViewController._layoutViewSubviews();
+            //UIView.layoutViewsIfNeeded()
+            this.rootViewController.view.broadcastEventInSubtree({
+                name: UICore.broadcastEventName.WindowDidResize,
+                parameters: UIObject_1.nil
+            });
+        };
+        window.addEventListener("resize", windowDidResize.bind(this));
+        const didScroll = function () {
+            //code
+            this.rootViewController.view.broadcastEventInSubtree({
+                name: UIView_1.UIView.broadcastEventName.PageDidScroll,
+                parameters: UIObject_1.nil
+            });
+        }.bind(this);
+        window.addEventListener("scroll", didScroll, false);
+        const hashDidChange = function () {
+            //code
+            this.rootViewController.handleRouteRecursively(UIRoute_1.UIRoute.currentRoute);
+            this.rootViewController.view.broadcastEventInSubtree({
+                name: UICore.broadcastEventName.RouteDidChange,
+                parameters: UIObject_1.nil
+            });
+        }.bind(this);
+        window.addEventListener("hashchange", hashDidChange.bind(this), false);
+        hashDidChange();
+    }
+    static loadClass(className) {
+        if (window[className]) {
+            return;
+        }
+        document.writeln("<script type='text/javascript' src='dist/UICore/" + className + ".js'></script>");
+    }
+}
+exports.UICore = UICore;
+UICore.languageService = UIObject_1.nil;
+UICore.broadcastEventName = {
+    "RouteDidChange": "RouteDidChange",
+    "WindowDidResize": "WindowDidResize"
+};
+UICore.RootViewControllerClass = UIObject_1.nil;
+exports.IS_FIREFOX = navigator.userAgent.toLowerCase().indexOf("firefox") > -1;
+exports.IS_SAFARI = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+Array.prototype.indexOf || (Array.prototype.indexOf = function (d, e) {
+    var a;
+    if (null == this) {
+        throw new TypeError("\"this\" is null or not defined");
+    }
+    const c = Object(this), b = c.length >>> 0;
+    if (0 === b) {
+        return -1;
+    }
+    a = +e || 0;
+    Infinity === Math.abs(a) && (a = 0);
+    if (a >= b) {
+        return -1;
+    }
+    for (a = Math.max(0 <= a ? a : b - Math.abs(a), 0); a < b;) {
+        if (a in c && c[a] === d) {
+            return a;
+        }
+        a++;
+    }
+    return -1;
+});
+//# sourceMappingURL=UICore.js.map

package/compiledScripts/UICore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UICore.js","sourceRoot":"","sources":["../scripts/UICore.ts"],"names":[],"mappings":"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"}

package/compiledScripts/UICoreExtensions.d.ts

@@ -0,0 +1,60 @@
+declare global {
+    interface Array<T> {
+        removeElementAtIndex(index: number): any;
+        removeElement(element: T): any;
+        insertElementAtIndex(index: number, element: T): any;
+        replaceElementAtIndex(index: number, element: T): any;
+        contains(element: T): boolean;
+        groupedBy(keyFunction: (item: T) => any): {
+            [key: string]: Array<T>;
+        } & Object;
+        copy(): Array<T>;
+        arrayByRepeating(numberOfRepetitions: number): Array<T>;
+        arrayByTrimmingToLengthIfLonger(maxLength: number): Array<T>;
+        anyMatch(predicate: (value: T, index: number, obj: T[]) => boolean): boolean;
+        noneMatch(predicate: (value: T, index: number, obj: T[]) => boolean): boolean;
+        allMatch(predicate: (value: T, index: number, obj: T[]) => boolean): boolean;
+        readonly firstElement: T;
+        readonly lastElement: T;
+        readonly summedValue: T;
+        max(): number;
+        min(): number;
+        isEqualToArray(array: Array<T>, keyPath?: string): boolean;
+    }
+    interface String {
+        contains(string: any): boolean;
+        readonly numericalValue: number;
+        isAString: boolean;
+    }
+    interface Number {
+        isANumber: boolean;
+        readonly integerValue: number;
+    }
+    interface Date {
+        readonly dateString: string;
+    }
+    interface Object {
+        forEach(callbackFunction: (value: any, key: string) => void): void;
+        readonly allValues: Array<any>;
+        readonly allKeys: string[];
+    }
+}
+export {};
+export declare type UIEveryElementItem<T> = {
+    [P in keyof T]: UIEveryElementItem<T[P]>;
+} & {
+    UI_elementValues?: T[];
+} & T;
+export declare class UICoreExtensionValueObject {
+    isAUICoreExtensionValueObject: boolean;
+    value: any;
+    constructor(value: any);
+}
+export declare type Unpacked<T> = T extends (infer U)[] ? U : T extends (...args: any[]) => infer U ? U : T extends Promise<infer U> ? U : T;
+export declare type UnpackedObject<T> = {
+    [P in keyof T]: Unpacked<T[P]>;
+};
+export declare function promisedProperties<ObjectType extends object>(object: ObjectType): UnpackedObject<ObjectType>;
+export declare class PrimitiveNumber {
+    static [Symbol.hasInstance](x: any): void;
+}

package/compiledScripts/UICoreExtensions.js

@@ -0,0 +1,527 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrimitiveNumber = exports.promisedProperties = exports.UICoreExtensionValueObject = void 0;
+const UIObject_1 = require("./UIObject");
+if ("removeElementAtIndex" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.removeElementAtIndex = function (index) {
+        // @ts-ignore
+        if (index >= 0 && index < this.length) {
+            this.splice(index, 1);
+        }
+    };
+}
+// interface Array<T> {
+//
+//     removeElementAtIndex(index: number);
+//
+// }
+if ("removeElement" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.removeElement = function (element) {
+        this.removeElementAtIndex(this.indexOf(element));
+    };
+}
+// interface Array<T> {
+//
+//     removeElement(element: T);
+//
+// }
+if ("insertElementAtIndex" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.insertElementAtIndex = function (index, element) {
+        if (index >= 0 && index <= this.length) {
+            this.splice(index, 0, element);
+        }
+    };
+}
+// interface Array<T> {
+//
+//     insertElementAtIndex(index: number, element: T);
+//
+// }
+if ("replaceElementAtIndex" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.replaceElementAtIndex = function (index, element) {
+        this.removeElementAtIndex(index);
+        this.insertElementAtIndex(index, element);
+    };
+}
+// interface Array<T> {
+//
+//     replaceElementAtIndex(index: number, element: T);
+//
+// }
+if ("contains" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.contains = function (element) {
+        const result = (this.indexOf(element) != -1);
+        return result;
+    };
+}
+if ("containsAny" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.containsAny = function (elements) {
+        const result = this.anyMatch(function (element, index, array) {
+            return elements.contains(element);
+        });
+        return result;
+    };
+}
+// interface Array<T> {
+//
+//     contains(element: T): boolean;
+//
+//     containsAny(element: T[]): boolean;
+//
+// }
+if ("anyMatch" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.anyMatch = function (functionToCall) {
+        // @ts-ignore
+        const result = (this.findIndex(functionToCall) > -1);
+        return result;
+    };
+}
+if ("noneMatch" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.noneMatch = function (functionToCall) {
+        // @ts-ignore
+        const result = (this.findIndex(functionToCall) == -1);
+        return result;
+    };
+}
+if ("allMatch" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.allMatch = function (functionToCall) {
+        function reversedFunction(value, index, array) {
+            return !functionToCall(value, index, array);
+        }
+        // @ts-ignore
+        const result = (this.findIndex(reversedFunction) == -1);
+        return result;
+    };
+}
+// interface Array<T> {
+//
+//     anyMatch(predicate: (value: T, index: number, obj: T[]) => boolean): boolean
+//
+//     noneMatch(predicate: (value: T, index: number, obj: T[]) => boolean): boolean
+//
+//     allMatch(predicate: (value: T, index: number, obj: T[]) => boolean): boolean
+//
+// }
+if ("groupedBy" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.groupedBy = function (funcProp) {
+        return this.reduce(function (acc, val) {
+            (acc[funcProp(val)] = acc[funcProp(val)] || []).push(val);
+            return acc;
+        }, {});
+    };
+}
+// interface Array<T> {
+//
+//     groupedBy(keyFunction: (item: T) => any): { [key: string]: Array<T> };
+//
+// }
+if ("firstElement" in Array.prototype == UIObject_1.NO) {
+    Object.defineProperty(Array.prototype, "firstElement", {
+        get: function firstElement() {
+            const result = this[0];
+            return result;
+        },
+        set: function (element) {
+            if (this.length == 0) {
+                this.push(element);
+                return;
+            }
+            this[0] = element;
+        }
+    });
+}
+if ("lastElement" in Array.prototype == UIObject_1.NO) {
+    Object.defineProperty(Array.prototype, "lastElement", {
+        get: function lastElement() {
+            const result = this[this.length - 1];
+            return result;
+        },
+        set: function (element) {
+            if (this.length == 0) {
+                this.push(element);
+                return;
+            }
+            this[this.length - 1] = element;
+        }
+    });
+}
+if ("everyElement" in Array.prototype == UIObject_1.NO) {
+    Object.defineProperty(Array.prototype, "everyElement", {
+        get: function everyElement() {
+            var valueKeys = [];
+            const targetFunction = (objects) => {
+                return this.map((element, index, array) => {
+                    var elementFunction = UIObject_1.UIObject.valueForKeyPath(valueKeys.join("."), element).bind(element, objects);
+                    return elementFunction();
+                });
+            };
+            const result = new Proxy(targetFunction, {
+                get: (target, key, receiver) => {
+                    if (key == "UI_elementValues") {
+                        return this.map((element, index, array) => UIObject_1.UIObject.valueForKeyPath(valueKeys.join("."), element));
+                    }
+                    valueKeys.push(key);
+                    return result;
+                },
+                set: (target, key, value, receiver) => {
+                    valueKeys.push(key);
+                    this.forEach((element, index, array) => {
+                        UIObject_1.UIObject.setValueForKeyPath(valueKeys.join("."), value, element, UIObject_1.YES);
+                    });
+                    return true;
+                }
+            });
+            return result;
+        },
+        set: function (element) {
+            for (var i = 0; i < this.length; ++i) {
+                this[i] = element;
+            }
+        }
+    });
+}
+// interface Array<T> {
+//
+//     firstElement: T;
+//     lastElement: T;
+//
+//     everyElement: UIEveryElementItem<T>;
+//
+// }
+if ("copy" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.copy = function () {
+        const result = this.slice(0);
+        return result;
+    };
+}
+// interface Array<T> {
+//
+//     copy(): Array<T>;
+//
+// }
+if ("arrayByRepeating" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.arrayByRepeating = function (numberOfRepetitions) {
+        const result = [];
+        for (var i = 0; i < numberOfRepetitions; i++) {
+            this.forEach(function (element, index, array) {
+                result.push(element);
+            });
+        }
+        return result;
+    };
+}
+// interface Array<T> {
+//
+//     arrayByRepeating(numberOfRepetitions: number): Array<T>;
+//
+// }
+if ("arrayByTrimmingToLengthIfLonger" in Array.prototype == UIObject_1.NO) {
+    Array.prototype.arrayByTrimmingToLengthIfLonger = function (maxLength) {
+        const result = [];
+        for (var i = 0; i < maxLength && i < this.length; i++) {
+            result.push(this[i]);
+        }
+        return result;
+    };
+}
+// interface Array<T> {
+//
+//     arrayByTrimmingToLengthIfLonger(maxLength: number): Array<T>;
+//
+// }
+if ("summedValue" in Array.prototype == UIObject_1.NO) {
+    Object.defineProperty(Array.prototype, "summedValue", {
+        get: function summedValue() {
+            const result = this.reduce(function (a, b) {
+                return a + b;
+            }, 0);
+            return result;
+        }
+    });
+}
+// interface Array<T> {
+//
+//     readonly summedValue: T;
+//
+//     max(): number;
+//     min(): number;
+//
+//
+// }
+Array.prototype.max = function () {
+    return Math.max.apply(null, this);
+};
+Array.prototype.min = function () {
+    return Math.min.apply(null, this);
+};
+// interface Array<T> {
+//
+//     isEqualToArray(array: Array<T>, keyPath?: string): boolean;
+//
+// }
+// Warn if overriding existing method
+if ("isEqualToArray" in Array.prototype == UIObject_1.YES) {
+    console.warn("Overriding existing Array.prototype.isEqualToArray. Possible causes: New API defines the method, there's a framework conflict or you've got double inclusions in your code.");
+}
+// attach the .equals method to Array's prototype to call it on any array
+Array.prototype.isEqualToArray = function (array, keyPath) {
+    // if the other array is a falsy value, return
+    if (!array) {
+        return false;
+    }
+    // compare lengths - can save a lot of time 
+    if (this.length != array.length) {
+        return false;
+    }
+    var i = 0;
+    const l = this.length;
+    for (; i < l; i++) {
+        // Check if we have nested arrays
+        if (this[i] instanceof Array && array[i] instanceof Array && !keyPath) {
+            // recurse into the nested arrays
+            if (!this[i].isEqualToArray(array[i])) {
+                return false;
+            }
+        }
+        else if (keyPath && UIObject_1.UIObject.valueForKeyPath(keyPath, this[i]) != UIObject_1.UIObject.valueForKeyPath(keyPath, array[i])) {
+            return false;
+        }
+        else if (this[i] != array[i]) {
+            // Warning - two different object instances will never be equal: {x:20} != {x:20}
+            return false;
+        }
+    }
+    return true;
+};
+// Hide method from for-in loops
+Object.defineProperty(Array.prototype, "isEqualToArray", { enumerable: false });
+if ("forEach" in Object.prototype == UIObject_1.NO) {
+    Object.prototype.forEach = function (callbackFunction) {
+        const keys = Object.keys(this);
+        keys.forEach(function (key, index, array) {
+            callbackFunction(this[key], key);
+        }.bind(this));
+    };
+    // Hide method from for-in loops
+    Object.defineProperty(Object.prototype, "forEach", { enumerable: false });
+}
+// interface Object {
+//
+//     forEach(callbackFunction: (value: any, key: string) => void): void;
+//
+// }
+if ("allValues" in Object.prototype == UIObject_1.NO) {
+    Object.defineProperty(Object.prototype, "allValues", {
+        get: function () {
+            const values = [];
+            this.forEach(function (value) {
+                values.push(value);
+            });
+            return values;
+        }
+    });
+}
+// interface Object {
+//
+//     readonly allValues: Array<any>;
+//
+// }
+if ("allKeys" in Object.prototype == UIObject_1.NO) {
+    Object.defineProperty(Object.prototype, "allKeys", {
+        get: function () {
+            const values = Object.keys(this);
+            return values;
+        }
+    });
+}
+// interface Object {
+//
+//     readonly allKeys: string[];
+//
+// }
+if ("objectByCopyingValuesRecursivelyFromObject" in Object.prototype == UIObject_1.NO) {
+    Object.prototype.objectByCopyingValuesRecursivelyFromObject = function (object) {
+        function isAnObject(item) {
+            return (item && typeof item === "object" && !Array.isArray(item));
+        }
+        function mergeRecursively(target, source) {
+            const output = Object.assign({}, target);
+            if (isAnObject(target) && isAnObject(source)) {
+                Object.keys(source).forEach(function (key) {
+                    if (isAnObject(source[key])) {
+                        // if (!(key in target)) {
+                        //     Object.assign(output, { [key]: source[key] });
+                        // }
+                        // else {
+                        output[key] = mergeRecursively(target[key], source[key]);
+                        //}
+                    }
+                    else {
+                        Object.assign(output, { [key]: source[key] });
+                    }
+                });
+            }
+            return output;
+        }
+        const result = mergeRecursively(this, object);
+        return result;
+    };
+    // Hide method from for-in loops
+    Object.defineProperty(Object.prototype, "objectByCopyingValuesRecursivelyFromObject", { enumerable: false });
+}
+class UICoreExtensionValueObject {
+    constructor(value) {
+        this.isAUICoreExtensionValueObject = UIObject_1.YES;
+        this.value = value;
+    }
+}
+exports.UICoreExtensionValueObject = UICoreExtensionValueObject;
+if ("asValueObject" in Object.prototype == UIObject_1.NO) {
+    Object.prototype.asValueObject = function () {
+        const result = new UICoreExtensionValueObject(this);
+        return result;
+    };
+    // Hide method from for-in loops
+    Object.defineProperty(Object.prototype, "asValueObject", { enumerable: false });
+}
+function promisedProperties(object) {
+    let promisedProperties = [];
+    const objectKeys = Object.keys(object);
+    objectKeys.forEach((key) => promisedProperties.push(object[key]));
+    // @ts-ignore
+    return Promise.all(promisedProperties)
+        .then((resolvedValues) => {
+        return resolvedValues.reduce((resolvedObject, property, index) => {
+            resolvedObject[objectKeys[index]] = property;
+            return resolvedObject;
+        }, object);
+    });
+}
+exports.promisedProperties = promisedProperties;
+// if ("promisedProperties" in Object.prototype == NO) {
+//
+//     (Object.prototype as any).promisedProperties = function () {
+//
+//         const result = promisedProperties(this);
+//
+//         return result
+//
+//     }
+//
+//     // Hide method from for-in loops
+//     Object.defineProperty(Object.prototype, "promisedProperties", { enumerable: false });
+//
+// }
+//
+//
+// interface Object {
+//
+//     readonly promisedProperties: UnpackedObject<this>;
+//
+// }
+if ("contains" in String.prototype == UIObject_1.NO) {
+    String.prototype.contains = function (string) {
+        const result = (this.indexOf(string) != -1);
+        return result;
+    };
+    // Hide method from for-in loops
+    Object.defineProperty(Object.prototype, "contains", { enumerable: false });
+}
+// interface String {
+//
+//     contains(string): boolean;
+//
+// }
+if ("capitalizedString" in String.prototype == UIObject_1.NO) {
+    Object.defineProperty(Object.prototype, "capitalizedString", {
+        get: function () {
+            const result = this.charAt(0).toUpperCase() + this.slice(1).toLowerCase();
+            return result;
+        }
+    });
+}
+// interface String {
+//
+//     readonly capitalizedString: string;
+//
+// }
+if ("numericalValue" in String.prototype == UIObject_1.NO) {
+    Object.defineProperty(String.prototype, "numericalValue", {
+        get: function numericalValue() {
+            const result = Number(this);
+            return result;
+        }
+    });
+}
+// interface String {
+//
+//     readonly numericalValue: number;
+//
+// }
+if ("isAString" in String.prototype == UIObject_1.NO) {
+    String.prototype.isAString = UIObject_1.YES;
+}
+// interface String {
+//
+//     isAString: boolean;
+//
+// }
+if ("isANumber" in Number.prototype == UIObject_1.NO) {
+    Number.prototype.isANumber = UIObject_1.YES;
+}
+// interface Number {
+//
+//     isANumber: boolean;
+//
+// }
+if ("integerValue" in Number.prototype == UIObject_1.NO) {
+    Object.defineProperty(Number.prototype, "integerValue", {
+        get: function () {
+            const result = parseInt("" + (Math.round(this) + 0.5));
+            return result;
+        }
+    });
+}
+// interface Number {
+//
+//     readonly integerValue: number;
+//
+// }
+class PrimitiveNumber {
+    // @ts-ignore
+    static [Symbol.hasInstance](x) {
+        return;
+    }
+}
+exports.PrimitiveNumber = PrimitiveNumber;
+if ("integerValue" in Boolean.prototype == UIObject_1.NO) {
+    Object.defineProperty(Boolean.prototype, "integerValue", {
+        get: function () {
+            if (this == true) {
+                return 1;
+            }
+            return 0;
+        }
+    });
+}
+// interface Boolean {
+//
+//     readonly integerValue: number;
+//
+// }
+if ("dateString" in Date.prototype == UIObject_1.NO) {
+    Object.defineProperty(Date.prototype, "dateString", {
+        get: function dateString() {
+            const result = ("0" + this.getDate()).slice(-2) + "-" + ("0" + (this.getMonth() + 1)).slice(-2) + "-" +
+                this.getFullYear() + " " + ("0" + this.getHours()).slice(-2) + ":" +
+                ("0" + this.getMinutes()).slice(-2);
+            return result;
+        }
+    });
+}
+// interface Date {
+//
+//     readonly dateString: string;
+//
+// }
+//# sourceMappingURL=UICoreExtensions.js.map