uicore-ts 1.0.1

package/scripts/UIKeyValueStringSorter.ts

@@ -0,0 +1,337 @@
+import { IS, IS_NOT, MAKE_ID, NO, UIObject, YES } from "./UIObject"
+
+
+export interface UIKeyValueStringSorterSortingInstruction {
+    
+    keyPath: string;
+    
+    dataType: string;
+    
+    direction: string;
+    
+    
+}
+
+
+
+
+
+export class UIKeyValueStringSorter extends UIObject {
+    
+    
+    static _sharedWebWorkerHolder = { webWorker: new Worker("compiledScripts//UIKeyValueStringSorterWebWorker.js") }
+    
+    static _instanceNumber = -1
+    
+    
+    _instanceNumber: number
+    
+    _isThreadClosed = NO
+    
+    private _webWorkerHolder = UIKeyValueStringSorter._sharedWebWorkerHolder
+    
+    
+    constructor(useSeparateWebWorkerHolder = NO) {
+        
+        
+        super()
+        
+        this._class = UIKeyValueStringSorter
+        this.superclass = UIObject
+        
+        
+        if (useSeparateWebWorkerHolder) {
+            
+            this._webWorkerHolder = { webWorker: new Worker("compiledScripts//UIKeyValueStringSorterWebWorker.js") }
+            
+        }
+        
+        UIKeyValueStringSorter._instanceNumber = UIKeyValueStringSorter._instanceNumber + 1
+        this._instanceNumber = UIKeyValueStringSorter._instanceNumber
+        
+        if (IS_NOT(this._webWorkerHolder.webWorker.onmessage)) {
+            
+            this._webWorkerHolder.webWorker.onmessage = message => {
+    
+                this.isWorkerBusy = NO;
+                this.postNextMessageIfNeeded();
+                
+                const key = "" + message.data.identifier + message.data.instanceIdentifier
+        
+                const completionFunction = this.completionFunctions[key]
+        
+                if (IS(completionFunction)) {
+            
+                    //console.log("Filtering took " + (Date.now() - startTime) + " ms");
+            
+                    completionFunction(message.data.sortedData, message.data.sortedIndexes, message.data.identifier)
+            
+                }
+                
+                delete this.completionFunctions[key];
+                
+                var asd = 1;
+                
+            }
+            
+        }
+        
+        
+        
+        
+        
+        
+        
+        
+        
+    }
+    
+    
+    
+    
+    
+    get instanceIdentifier() {
+        
+        return this._instanceNumber
+        
+    }
+    
+    
+    
+    
+    get completionFunctions() {
+        
+        const key = "UICore_completionFunctions";
+        var result: {
+        
+            [x: string]: (sortedData: any[], sortedIndexes: number[], identifier: any) => void
+            
+        } = this._webWorkerHolder[key];
+        
+        if (IS_NOT(result)) {
+            
+            result = {};
+            this._webWorkerHolder[key] = result;
+            
+        }
+        
+        return result;
+        
+    }
+    
+    get messagesToPost() {
+        
+        const key = "UICore_messagesToPost";
+        var result: any[] = this._webWorkerHolder[key];
+        
+        if (IS_NOT(result)) {
+            
+            result = [];
+            this._webWorkerHolder[key] = result;
+            
+        }
+        
+        return result;
+        
+    }
+    
+    
+    set isWorkerBusy(isWorkerBusy: boolean) {
+        
+        this._webWorkerHolder["UICore_isWorking"] = isWorkerBusy;
+        
+    }
+    
+    get isWorkerBusy() {
+        
+        return IS(this._webWorkerHolder["UICore_isWorking"]);
+        
+    }
+    
+    
+    postNextMessageIfNeeded() {
+        
+        if (this.messagesToPost.length && IS_NOT(this.isWorkerBusy)) {
+            
+            this._webWorkerHolder.webWorker.postMessage(this.messagesToPost.firstElement);
+            this.messagesToPost.removeElementAtIndex(0);
+            
+            this.isWorkerBusy = YES;
+            
+        }
+        
+    }
+    
+    
+    
+    
+    
+    static dataType = {
+        
+        "string": "string"
+        
+    }
+    
+    
+    static direction = {
+        
+        "descending": "descending",
+        "ascending": "ascending"
+        
+    }
+    
+    
+    
+    
+    
+    sortData<T>(
+        data: T[],
+        sortingInstructions: UIKeyValueStringSorterSortingInstruction[],
+        identifier: any,
+        completion: (sortedData: T[], sortedIndexes: number[], identifier: any) => void
+    ) {
+        
+        
+        if (this._isThreadClosed) {
+            
+            return
+            
+        }
+    
+        
+        const instanceIdentifier = this.instanceIdentifier
+        
+        const key = "" + identifier + instanceIdentifier
+        
+        this.completionFunctions[key] = completion;
+        
+        
+        try {
+            
+            this.messagesToPost.push({
+                
+                "data": data,
+                "sortingInstructions": sortingInstructions,
+                "identifier": identifier,
+                "instanceIdentifier": instanceIdentifier
+                
+            });
+            
+            this.postNextMessageIfNeeded();
+            
+        } catch (exception) {
+            
+            completion([], [], identifier)
+            
+        }
+        
+        
+        
+        
+        
+    }
+    
+    
+    
+    
+    
+    sortedData<T>(
+        data: T[],
+        sortingInstructions: UIKeyValueStringSorterSortingInstruction[],
+        identifier: any = MAKE_ID()
+    ) {
+    
+        const result: Promise<{
+        
+            sortedData: T[],
+            sortedIndexes: number[],
+            identifier: any
+        
+        }> = new Promise((resolve, reject) => {
+        
+            this.sortData(data, sortingInstructions, identifier, (sortedData, sortedIndexes, sortedIdentifier) => {
+    
+                if (sortedIdentifier == identifier) {
+    
+                    resolve({
+        
+                        sortedData: sortedData,
+                        sortedIndexes: sortedIndexes,
+                        identifier: sortedIdentifier
+        
+                    })
+        
+                }
+                
+                
+            
+            })
+        
+        
+        
+        })
+    
+        return result
+        
+    }
+    
+    
+    
+    
+    
+    closeThread() {
+        
+        this._isThreadClosed = YES
+        
+        if (this._webWorkerHolder != UIKeyValueStringSorter._sharedWebWorkerHolder) {
+            
+            this._webWorkerHolder.webWorker.terminate();
+            
+        }
+        
+        
+        
+    }
+    
+    
+    
+    
+    
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/scripts/UILayoutGrid.ts

@@ -0,0 +1,83 @@
+import { UIObject } from "./UIObject"
+import { UIRectangle } from "./UIRectangle"
+
+
+export class UILayoutGrid extends UIObject {
+    
+    
+    
+    _frame: UIRectangle
+    
+    _subframes: UILayoutGrid[] = []
+    
+    
+    constructor(frame: UIRectangle) {
+        
+        super()
+        
+        this._class = UILayoutGrid
+        this.superclass = UIObject
+        
+        this._frame = frame
+        
+    }
+    
+    
+    
+    
+    
+    splitXInto(numberOfFrames: number) {
+        
+        
+        
+        if (this._subframes.length == 0) {
+            
+            
+            
+            for (var i = 0; i < numberOfFrames; i++) {
+    
+                const asd = 1
+    
+    
+    
+            }
+            
+        }
+        
+        
+        
+        
+    }
+    
+    
+    
+    
+    
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/scripts/UILink.ts

@@ -0,0 +1,292 @@
+import { UIBaseButton } from "./UIBaseButton"
+import { UIButtonColorSpecifier } from "./UIButton"
+import { UICore } from "./UICore"
+import { nil, NO } from "./UIObject"
+import { UIRoute } from "./UIRoute"
+import { UIViewBroadcastEvent } from "./UIView"
+
+
+
+
+
+export class UILink extends UIBaseButton {
+    
+    
+    
+    private _colors: UIButtonColorSpecifier
+    
+    
+    constructor(elementID: string, initViewData = nil) {
+        
+        super(elementID, "a", initViewData)
+        
+        this._class = UILink
+        this.superclass = UIBaseButton
+        
+        this.stopsPointerEventPropagation = NO
+        
+        this.pausesPointerEvents = NO
+        
+        
+        
+    }
+    
+    
+    
+    
+    
+    initView(elementID, viewHTMLElement, initViewData: { titleType: string }) {
+        
+        super.initView(elementID, viewHTMLElement, initViewData)
+        
+        this.class.superclass = UIBaseButton
+        
+        // Instance variables
+        
+        
+        //this.style.position = "relative"
+        
+        
+        viewHTMLElement.onclick = this.blur.bind(this)
+        
+        
+        
+        
+    }
+    
+    
+    
+    
+    
+    get colors(): UIButtonColorSpecifier {
+        return this._colors
+    }
+    
+    set colors(value: UIButtonColorSpecifier) {
+        this._colors = value
+    }
+    
+    
+    
+    
+    
+    get viewHTMLElement() {
+        
+        // @ts-ignore
+        return super.viewHTMLElement as HTMLLinkElement
+        
+    }
+    
+    set text(text: string) {
+        
+        this.viewHTMLElement.textContent = text
+        
+    }
+    
+    get text() {
+        
+        return this.viewHTMLElement.textContent
+        
+    }
+    
+    
+    set target(target: string) {
+        
+        this.viewHTMLElement.setAttribute("href", target)
+        
+    }
+    
+    get target() {
+    
+        const result = this.viewHTMLElement.getAttribute("href")
+    
+        return result
+        
+    }
+    
+    
+    
+    
+    
+    set targetRouteForCurrentState(targetRouteForCurrentState: () => (UIRoute | string)) {
+        
+        this._targetRouteForCurrentState = targetRouteForCurrentState
+        
+        this.updateTarget()
+        
+    }
+    
+    get targetRouteForCurrentState() {
+        
+        return this._targetRouteForCurrentState
+        
+    }
+    
+    
+    _targetRouteForCurrentState() {
+    
+        const result = UIRoute.currentRoute.routeByRemovingComponentsOtherThanOnesNamed(["settings"]) as (UIRoute | string)
+    
+        return result
+        
+    }
+    
+    
+    
+    
+    
+    didReceiveBroadcastEvent(event: UIViewBroadcastEvent) {
+        
+        super.didReceiveBroadcastEvent(event)
+        
+        if (event.name == UICore.broadcastEventName.RouteDidChange) {
+            
+            this.updateTarget()
+            
+        }
+        
+    }
+    
+    
+    
+    
+    
+    wasAddedToViewTree() {
+        
+        super.wasAddedToViewTree()
+        
+        this.updateTarget()
+        
+        
+    }
+    
+    
+    
+    
+    
+    updateTarget() {
+        
+        const route = this.targetRouteForCurrentState()
+        
+        if (route instanceof UIRoute) {
+            
+            this.target = route.linkRepresentation
+            
+            return
+            
+        }
+        
+        this.target = route
+        
+    }
+    
+    
+    
+    
+    
+    layoutSubviews() {
+        
+        super.layoutSubviews()
+    
+        const bounds = this.bounds
+    
+    }
+    
+    
+    
+    
+    
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+