@openglobus/og 0.18.0 → 0.18.2

package/{src/ui/View.ts → lib/js/ui/View.js}

@@ -1,53 +1,23 @@
-import {createEvents, EventsHandler} from '../Events';
-import {parseHTML, stringTemplate} from '../utils/shared';
-
-export interface IViewParams {
-    model?: any;
-    template?: string;
-    parent?: View<any> | null;
-    classList?: string[];
-}
-
-export type ViewEventsList = ["render"];
-const VIEW_EVENTS: ViewEventsList = ["render"];
-
-class View<M> {
-
-    static __counter__: number = 0;
-
-    protected __id: number;
-
-    public events: EventsHandler<ViewEventsList>;
-
-    public model: M;
-
-    public template: string;
-
-    public parent: View<any> | null;
-
-    public el: HTMLElement | null;
-
-    protected _classList: string[];
-
-    constructor(options: IViewParams = {}) {
+import { createEvents } from '../Events';
+import { parseHTML, stringTemplate } from '../utils/shared';
+const VIEW_EVENTS = ["render"];
+class View {
+    constructor(options = {}) {
         this.__id = View.__counter__++;
-        this.events = createEvents<ViewEventsList>(VIEW_EVENTS);
+        this.events = createEvents(VIEW_EVENTS);
         this.model = options.model || null;
         this.template = options.template || "";
         this.parent = options.parent || null;
         this._classList = options.classList || [];
         this.el = null;
     }
-
-    static getHTML(template: string, params: any): string {
+    static getHTML(template, params) {
         return stringTemplate(template, params);
     }
-
-    static parseHTML(htmlStr: string): HTMLElement[] {
+    static parseHTML(htmlStr) {
         return parseHTML(htmlStr);
     }
-
-    static insertAfter(newNodes: HTMLElement | HTMLElement[], referenceNode: Node): HTMLElement[] {
+    static insertAfter(newNodes, referenceNode) {
         if (!Array.isArray(newNodes)) {
             newNodes = [newNodes];
         }
@@ -58,8 +28,7 @@ class View<M> {
         }
         return newNodes;
     }
-
-    static insertBefore(newNodes: HTMLElement | HTMLElement[], referenceNode: Node): HTMLElement[] {
+    static insertBefore(newNodes, referenceNode) {
         if (!Array.isArray(newNodes)) {
             newNodes = [newNodes];
         }
@@ -70,8 +39,7 @@ class View<M> {
         }
         return newNodes;
     }
-
-    public insertBefore(view: View<any> | HTMLElement) {
+    insertBefore(view) {
         if (!this.el) {
             this.render();
         }
@@ -84,8 +52,7 @@ class View<M> {
             }
         }
     }
-
-    public insertAfter(view: View<any> | HTMLElement) {
+    insertAfter(view) {
         if (!this.el) {
             this.render();
         }
@@ -98,58 +65,49 @@ class View<M> {
             }
         }
     }
-
-    public isEqual(view: View<any>): boolean {
+    isEqual(view) {
         return view.__id === this.__id;
     }
-
-    public appendTo(node: HTMLElement, clean: boolean = false, firstPosition: boolean = false) {
+    appendTo(node, clean = false, firstPosition = false) {
         if (node) {
             if (!this.el) {
                 this.beforeRender(node);
                 this.render();
             }
-
             if (this.el && this.el.parentNode) {
                 this.el.parentNode.removeChild(this.el);
             }
-
             if (clean) {
                 node.innerHTML = "";
             }
-
             if (this.el) {
                 if (firstPosition) {
                     if (node.childNodes[0]) {
                         View.insertBefore(this.el, node.childNodes[0]);
-                    } else {
+                    }
+                    else {
                         node.appendChild(this.el);
                     }
-                } else {
+                }
+                else {
                     node.appendChild(this.el);
                 }
             }
             this.afterRender(node);
         }
-
         return this;
     }
-
-    public afterRender(parentNode: HTMLElement) {
+    afterRender(parentNode) {
     }
-
-    public beforeRender(parentNode: HTMLElement) {
+    beforeRender(parentNode) {
     }
-
-    public stopPropagation() {
+    stopPropagation() {
         this.events.stopPropagation();
     }
-
-    public renderTemplate(params: any): HTMLElement {
+    renderTemplate(params) {
         return View.parseHTML(View.getHTML(this.template, params || {}))[0];
     }
-
-    public render(params?: any): this {
+    render(params) {
         this.el = this.renderTemplate(params);
         for (let i = 0, len = this._classList.length; i < len; i++) {
             this.el.classList.add(this._classList[i]);
@@ -157,15 +115,13 @@ class View<M> {
         this.events.dispatch(this.events.render, this);
         return this;
     }
-
-    public select<T extends HTMLElement>(queryStr: string): T | null {
+    select(queryStr) {
         if (this.el) {
-            return this.el.querySelector<T>(queryStr);
+            return this.el.querySelector(queryStr);
         }
-        return null as T | null;
+        return null;
     }
-
-    public selectRemove(queryStr: string): HTMLElement | undefined {
+    selectRemove(queryStr) {
         if (this.el) {
             let r = this.select(queryStr);
             if (r && r.parentNode) {
@@ -174,8 +130,7 @@ class View<M> {
             }
         }
     }
-
-    public selectAll(queryStr: string, callback?: Function) {
+    selectAll(queryStr, callback) {
         if (this.el) {
             const res = this.el.querySelectorAll(queryStr);
             if (callback) {
@@ -186,12 +141,11 @@ class View<M> {
             return res;
         }
     }
-
-    public remove() {
+    remove() {
         if (this.el && this.el.parentNode) {
             this.el.parentNode.removeChild(this.el);
         }
     }
 }
-
-export {View};
+View.__counter__ = 0;
+export { View };

package/lib/js/ui/icons.d.ts

@@ -0,0 +1 @@
+export declare const CLOSE_ICON = "<svg className=\"svg-icon\" style=\"width: 1em; height: 1em;vertical-align: middle;fill: currentColor; overflow: hidden;\" viewBox=\"0 0 1024 1024\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">\n    <path d=\"M777.856 280.192l-33.92-33.952-231.872 231.872-231.84-231.872-33.984 33.888 231.872 231.904-231.84 231.84 33.888 33.984 231.904-231.904 231.84 231.872 33.952-33.888-231.872-231.904z\"/>\n</svg>";

package/{src/ui/icons.ts → lib/js/ui/icons.js}

@@ -1,3 +1,3 @@
 export const CLOSE_ICON = `<svg className="svg-icon" style="width: 1em; height: 1em;vertical-align: middle;fill: currentColor; overflow: hidden;" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg">
     <path d="M777.856 280.192l-33.92-33.952-231.872 231.872-231.84-231.872-33.984 33.888 231.872 231.904-231.84 231.84 33.888 33.984 231.904-231.904 231.84 231.872 33.952-33.888-231.872-231.904z"/>
-</svg>`
+</svg>`;

package/lib/js/utils/BaseWorker.d.ts

@@ -0,0 +1,14 @@
+export declare class BaseWorker<T> {
+    protected _sourceId: number;
+    protected _source: Map<number, T>;
+    protected _pendingQueue: T[];
+    protected _numWorkers: number;
+    protected _workerQueue: Worker[];
+    constructor(numWorkers?: number, program?: string);
+    check(): void;
+    setProgram(program: string): void;
+    make(data: T): void;
+    protected _onMessage(e: MessageEvent): void;
+    destroy(): void;
+    get pendingQueue(): T[];
+}

package/{src/utils/BaseWorker.ts → lib/js/utils/BaseWorker.js}

@@ -1,13 +1,7 @@
-export class BaseWorker<T> {
-    protected _sourceId: number;
-    protected _source: Map<number, T>;
-    protected _pendingQueue: T[];
-    protected _numWorkers: number;
-    protected _workerQueue: Worker[];
-
-    constructor(numWorkers: number = 2, program?: string) {
+export class BaseWorker {
+    constructor(numWorkers = 2, program) {
         this._sourceId = 0;
-        this._source = new Map<number, T>();
+        this._source = new Map();
         this._pendingQueue = [];
         this._numWorkers = numWorkers;
         this._workerQueue = [];
@@ -15,34 +9,28 @@ export class BaseWorker<T> {
             this.setProgram(program);
         }
     }
-
-    public check() {
+    check() {
         if (this._pendingQueue.length) {
-            this.make(this._pendingQueue.pop()!);
+            this.make(this._pendingQueue.pop());
         }
     }
-
-    public setProgram(program: string) {
-        let p = new Blob([program], {type: "application/javascript"});
+    setProgram(program) {
+        let p = new Blob([program], { type: "application/javascript" });
         for (let i = 0; i < this._numWorkers; i++) {
             let w = new Worker(URL.createObjectURL(p));
-            w.onmessage = (e: MessageEvent) => {
+            w.onmessage = (e) => {
                 this._onMessage(e);
-                this._workerQueue && this._workerQueue.unshift(e.target as Worker);
+                this._workerQueue && this._workerQueue.unshift(e.target);
                 this.check();
-            }
+            };
             this._workerQueue.push(w);
         }
     }
-
-    public make(data: T) {
+    make(data) {
     }
-
-    protected _onMessage(e: MessageEvent) {
-
+    _onMessage(e) {
     }
-
-    public destroy() {
+    destroy() {
         for (let i = 0; i < this._workerQueue.length; i++) {
             const w = this._workerQueue[i];
             w.onmessage = null;
@@ -53,8 +41,7 @@ export class BaseWorker<T> {
         //@ts-ignore
         this._workerQueue = null;
     }
-
-    public get pendingQueue(): T[] {
+    get pendingQueue() {
         return this._pendingQueue;
     }
-}
+}

package/lib/js/utils/FontAtlas.d.ts

@@ -0,0 +1,82 @@
+import { Deferred } from '../Deferred';
+import { Rectangle } from '../Rectangle';
+import { TextureAtlas, TextureAtlasNode } from './TextureAtlas';
+import { Handler } from "../webgl/Handler";
+import { HTMLImageElementExt } from "./ImagesCacheManager";
+interface IChar {
+    id: number;
+    char: string;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    chnl: number;
+    index: number;
+    page: number;
+    xadvance: number;
+    xoffset: number;
+    yoffset: number;
+}
+interface IKerning {
+    first: number;
+    second: number;
+    amount: number;
+}
+export interface IFontParams {
+    common: {
+        scaleH: number;
+        scaleW: number;
+    };
+    info: {
+        size: number;
+    };
+    distanceField: {
+        distanceRange: number;
+    };
+    chars: IChar[];
+    kernings: IKerning[];
+    pages: string[];
+}
+declare class FontTextureAtlas extends TextureAtlas {
+    width: number;
+    height: number;
+    gliphSize: number;
+    distanceRange: number;
+    nodes: Map<number, FontTextureAtlasNode>;
+    kernings: Record<number, Record<number, number>>;
+    constructor(width?: number, height?: number);
+    get(key: number): FontTextureAtlasNode | undefined;
+}
+interface IMetrics extends IChar {
+    nChar: string;
+    nCode: number;
+    nWidth: number;
+    nHeight: number;
+    nAdvance: number;
+    nXOffset: number;
+    nYOffset: number;
+}
+declare class FontTextureAtlasNode extends TextureAtlasNode {
+    metrics: IMetrics;
+    emptySize: number;
+    constructor(rect: Rectangle, texCoords: number[]);
+}
+declare class FontAtlas {
+    atlasesArr: FontTextureAtlas[];
+    samplerArr: Uint32Array;
+    sdfParamsArr: Float32Array;
+    catalogSrc: string;
+    protected atlasIndexes: Record<string, number>;
+    protected atlasIndexesDeferred: Record<string, Deferred<number>>;
+    protected tokenImageSize: number;
+    protected _handler: Handler | null;
+    constructor(catalogSrc?: string);
+    assignHandler(handler: Handler): void;
+    getFontIndex(face: string): Promise<number>;
+    getFullIndex(face: string): string;
+    protected _applyFontDataToAtlas(atlas: FontTextureAtlas, data: IFontParams, index?: number): void;
+    initFont(faceName: string, dataJson: IFontParams, imageBase64: string): void;
+    protected _createTexture(atlas: FontTextureAtlas, img: HTMLImageElementExt): void;
+    loadFont(faceName: string, srcDir: string, atlasUrl: string): void;
+}
+export { FontAtlas };