@safe-engine/cocos 1.0.1

package/dist/helper/html-text-parser.js

@@ -0,0 +1,354 @@
+"use strict";
+/* eslint-disable no-var */
+/* eslint-disable quotes */
+/* eslint-disable no-useless-escape */
+/* eslint-disable prettier/prettier */
+/****************************************************************************
+ Copyright (c) 2013-2016 Chukong Technologies Inc.
+ Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.
+
+ https://www.cocos.com/
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated engine source code (the "Software"), a limited,
+ worldwide, royalty-free, non-assignable, revocable and non-exclusive license
+ to use Cocos Creator solely to develop games on your target platforms. You shall
+ not use Cocos Creator software for developing other software or tools that's
+ used for developing games. You are not granted to publish, distribute,
+ sublicense, and/or sell copies of Cocos Creator.
+
+ The software or tools in this License Agreement are licensed, not sold.
+ Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ ****************************************************************************/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlTextParser = void 0;
+var eventRegx = /^(click)(\s)*=|(param)(\s)*=/;
+var imageAttrReg = /(\s)*src(\s)*=|(\s)*height(\s)*=|(\s)*width(\s)*=|(\s)*align(\s)*=|(\s)*offset(\s)*=|(\s)*click(\s)*=|(\s)*param(\s)*=/;
+/**
+ * A utils class for parsing HTML texts. The parsed results will be an object array.
+ */
+var HtmlTextParser = function () {
+    this._parsedObject = {};
+    this._specialSymbolArray = [];
+    this._specialSymbolArray.push([/&lt;/g, '<']);
+    this._specialSymbolArray.push([/&gt;/g, '>']);
+    this._specialSymbolArray.push([/&amp;/g, '&']);
+    this._specialSymbolArray.push([/&quot;/g, '"']);
+    this._specialSymbolArray.push([/&apos;/g, "'"]);
+    this._specialSymbolArray.push([/&nbsp;/g, ' ']);
+};
+exports.HtmlTextParser = HtmlTextParser;
+exports.HtmlTextParser.prototype = {
+    constructor: exports.HtmlTextParser,
+    parse: function (htmlString) {
+        this._resultObjectArray = [];
+        if (!htmlString) {
+            return this._resultObjectArray;
+        }
+        this._stack = [];
+        var startIndex = 0;
+        var length = htmlString.length;
+        while (startIndex < length) {
+            var tagEndIndex = htmlString.indexOf('>', startIndex);
+            var tagBeginIndex = -1;
+            if (tagEndIndex >= 0) {
+                tagBeginIndex = htmlString.lastIndexOf('<', tagEndIndex);
+                var noTagBegin = tagBeginIndex < startIndex - 1;
+                if (noTagBegin) {
+                    tagBeginIndex = htmlString.indexOf('<', tagEndIndex + 1);
+                    tagEndIndex = htmlString.indexOf('>', tagBeginIndex + 1);
+                }
+            }
+            if (tagBeginIndex < 0) {
+                this._stack.pop();
+                this._processResult(htmlString.substring(startIndex));
+                startIndex = length;
+            }
+            else {
+                var newStr = htmlString.substring(startIndex, tagBeginIndex);
+                var tagStr = htmlString.substring(tagBeginIndex + 1, tagEndIndex);
+                if (tagStr === '')
+                    newStr = htmlString.substring(startIndex, tagEndIndex + 1);
+                this._processResult(newStr);
+                if (tagEndIndex === -1) {
+                    // cc.error('The HTML tag is invalid!');
+                    tagEndIndex = tagBeginIndex;
+                }
+                else if (htmlString.charAt(tagBeginIndex + 1) === '/') {
+                    this._stack.pop();
+                }
+                else {
+                    this._addToStack(tagStr);
+                }
+                startIndex = tagEndIndex + 1;
+            }
+        }
+        return this._resultObjectArray;
+    },
+    _attributeToObject: function (attribute) {
+        attribute = attribute.trim();
+        var obj = {};
+        var header = attribute.match(/^(color|size)(\s)*=/);
+        var tagName;
+        var nextSpace;
+        var eventObj;
+        var eventHanlderString;
+        if (header) {
+            tagName = header[0];
+            attribute = attribute.substring(tagName.length).trim();
+            if (attribute === '')
+                return obj;
+            //parse color
+            nextSpace = attribute.indexOf(' ');
+            switch (tagName[0]) {
+                case 'c':
+                    if (nextSpace > -1) {
+                        obj.color = attribute.substring(0, nextSpace).trim();
+                    }
+                    else {
+                        obj.color = attribute;
+                    }
+                    break;
+                case 's':
+                    obj.size = parseInt(attribute);
+                    break;
+            }
+            //tag has event arguments
+            if (nextSpace > -1) {
+                eventHanlderString = attribute.substring(nextSpace + 1).trim();
+                eventObj = this._processEventHandler(eventHanlderString);
+                obj.event = eventObj;
+            }
+            return obj;
+        }
+        header = attribute.match(/^(br(\s)*\/)/);
+        if (header && header[0].length > 0) {
+            tagName = header[0].trim();
+            if (tagName.startsWith('br') && tagName[tagName.length - 1] === '/') {
+                obj.isNewLine = true;
+                this._resultObjectArray.push({ text: '', style: { newline: true } });
+                return obj;
+            }
+        }
+        header = attribute.match(/^(img(\s)*src(\s)*=[^>]+\/)/);
+        if (header && header[0].length > 0) {
+            tagName = header[0].trim();
+            if (tagName.startsWith('img') && tagName[tagName.length - 1] === '/') {
+                header = attribute.match(imageAttrReg);
+                var tagValue;
+                var remainingArgument;
+                var isValidImageTag = false;
+                while (header) {
+                    //skip the invalid tags at first
+                    attribute = attribute.substring(attribute.indexOf(header[0]));
+                    tagName = attribute.substr(0, header[0].length);
+                    //remove space and = character
+                    remainingArgument = attribute.substring(tagName.length).trim();
+                    nextSpace = remainingArgument.indexOf(' ');
+                    tagValue = nextSpace > -1 ? remainingArgument.substr(0, nextSpace) : remainingArgument;
+                    tagName = tagName.replace(/[^a-zA-Z]/g, '').trim();
+                    tagName = tagName.toLocaleLowerCase();
+                    attribute = remainingArgument.substring(nextSpace).trim();
+                    if (tagValue.endsWith('/'))
+                        tagValue = tagValue.slice(0, -1);
+                    if (tagName === 'src') {
+                        switch (tagValue.charCodeAt(0)) {
+                            case 34: // "
+                            case 39: // '
+                                isValidImageTag = true;
+                                tagValue = tagValue.slice(1, -1);
+                                break;
+                        }
+                        obj.isImage = true;
+                        obj.src = tagValue;
+                    }
+                    else if (tagName === 'height') {
+                        obj.imageHeight = parseInt(tagValue);
+                    }
+                    else if (tagName === 'width') {
+                        obj.imageWidth = parseInt(tagValue);
+                    }
+                    else if (tagName === 'align') {
+                        switch (tagValue.charCodeAt(0)) {
+                            case 34: // "
+                            case 39: // '
+                                tagValue = tagValue.slice(1, -1);
+                                break;
+                        }
+                        obj.imageAlign = tagValue.toLocaleLowerCase();
+                    }
+                    else if (tagName === 'offset') {
+                        obj.imageOffset = tagValue;
+                    }
+                    else if (tagName === 'click') {
+                        obj.event = this._processEventHandler("".concat(tagName, "=").concat(tagValue));
+                    }
+                    if (obj.event && tagName === 'param') {
+                        obj.event.param = tagValue.replace(/^\"|\"$/g, '');
+                    }
+                    header = attribute.match(imageAttrReg);
+                }
+                if (isValidImageTag && obj.isImage) {
+                    this._resultObjectArray.push({ text: '', style: obj });
+                }
+                return {};
+            }
+        }
+        header = attribute.match(/^(outline(\s)*[^>]*)/);
+        if (header) {
+            attribute = header[0].substring('outline'.length).trim();
+            var defaultOutlineObject = { color: '#ffffff', width: 1 };
+            if (attribute) {
+                var outlineAttrReg = /(\s)*color(\s)*=|(\s)*width(\s)*=|(\s)*click(\s)*=|(\s)*param(\s)*=/;
+                header = attribute.match(outlineAttrReg);
+                var tagValue;
+                while (header) {
+                    //skip the invalid tags at first
+                    attribute = attribute.substring(attribute.indexOf(header[0]));
+                    tagName = attribute.substr(0, header[0].length);
+                    //remove space and = character
+                    remainingArgument = attribute.substring(tagName.length).trim();
+                    nextSpace = remainingArgument.indexOf(' ');
+                    if (nextSpace > -1) {
+                        tagValue = remainingArgument.substr(0, nextSpace);
+                    }
+                    else {
+                        tagValue = remainingArgument;
+                    }
+                    tagName = tagName.replace(/[^a-zA-Z]/g, '').trim();
+                    tagName = tagName.toLocaleLowerCase();
+                    attribute = remainingArgument.substring(nextSpace).trim();
+                    if (tagName === 'click') {
+                        obj.event = this._processEventHandler("".concat(tagName, "=").concat(tagValue));
+                    }
+                    else if (tagName === 'color') {
+                        defaultOutlineObject.color = tagValue;
+                    }
+                    else if (tagName === 'width') {
+                        defaultOutlineObject.width = parseInt(tagValue);
+                    }
+                    if (obj.event && tagName === 'param') {
+                        obj.event.param = tagValue.replace(/^\"|\"$/g, '');
+                    }
+                    header = attribute.match(outlineAttrReg);
+                }
+            }
+            obj.outline = defaultOutlineObject;
+        }
+        header = attribute.match(/^(on|u|b|i)(\s)*/);
+        if (header && header[0].length > 0) {
+            tagName = header[0];
+            attribute = attribute.substring(tagName.length).trim();
+            switch (tagName[0]) {
+                case 'u':
+                    obj.underline = true;
+                    break;
+                case 'i':
+                    obj.italic = true;
+                    break;
+                case 'b':
+                    obj.bold = true;
+                    break;
+            }
+            if (attribute === '') {
+                return obj;
+            }
+            eventObj = this._processEventHandler(attribute);
+            obj.event = eventObj;
+        }
+        return obj;
+    },
+    _processEventHandler: function (eventString) {
+        var index = 0;
+        var obj = {};
+        var eventNames = eventString.match(eventRegx);
+        var isValidTag = false;
+        while (eventNames) {
+            var eventName = eventNames[0];
+            var eventValue = '';
+            isValidTag = false;
+            eventString = eventString.substring(eventName.length).trim();
+            if (eventString.charAt(0) === '"') {
+                index = eventString.indexOf('"', 1);
+                if (index > -1) {
+                    eventValue = eventString.substring(1, index).trim();
+                    isValidTag = true;
+                }
+                index++;
+            }
+            else if (eventString.charAt(0) === '\'') {
+                index = eventString.indexOf('\'', 1);
+                if (index > -1) {
+                    eventValue = eventString.substring(1, index).trim();
+                    isValidTag = true;
+                }
+                index++;
+            }
+            else {
+                //skip the invalid attribute value
+                var match = eventString.match(/(\S)+/);
+                if (match) {
+                    eventValue = match[0];
+                }
+                else {
+                    eventValue = '';
+                }
+                index = eventValue.length;
+            }
+            if (isValidTag) {
+                eventName = eventName.substring(0, eventName.length - 1).trim();
+                obj[eventName] = eventValue;
+            }
+            eventString = eventString.substring(index).trim();
+            eventNames = eventString.match(eventRegx);
+        }
+        return obj;
+    },
+    _addToStack: function (attribute) {
+        var obj = this._attributeToObject(attribute);
+        if (this._stack.length === 0) {
+            this._stack.push(obj);
+        }
+        else {
+            if (obj.isNewLine || obj.isImage) {
+                return;
+            }
+            //for nested tags
+            var previousTagObj = this._stack[this._stack.length - 1];
+            for (var key in previousTagObj) {
+                if (!obj[key]) {
+                    obj[key] = previousTagObj[key];
+                }
+            }
+            this._stack.push(obj);
+        }
+    },
+    _processResult: function (value) {
+        if (value === '') {
+            return;
+        }
+        value = this._escapeSpecialSymbol(value);
+        if (this._stack.length > 0) {
+            this._resultObjectArray.push({ text: value, style: this._stack[this._stack.length - 1] });
+        }
+        else {
+            this._resultObjectArray.push({ text: value });
+        }
+    },
+    _escapeSpecialSymbol: function (str) {
+        for (var i = 0; i < this._specialSymbolArray.length; ++i) {
+            var key = this._specialSymbolArray[i][0];
+            var value = this._specialSymbolArray[i][1];
+            str = str.replace(key, value);
+        }
+        return str;
+    },
+};

package/dist/helper/math.d.ts

@@ -0,0 +1,4 @@
+export declare function randomRangeInt(minInclude: Integer, maxExclude: Integer): number;
+export declare const degreesToRadians: typeof cc.degreesToRadians;
+export declare const radiansToDegrees: typeof cc.radiansToDegrees;
+//# sourceMappingURL=math.d.ts.map

package/dist/helper/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../src/helper/math.ts"],"names":[],"mappings":"AAAA,wBAAgB,cAAc,CAAC,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,UAEtE;AAED,eAAO,MAAM,gBAAgB,4BAAsB,CAAA;AACnD,eAAO,MAAM,gBAAgB,4BAAsB,CAAA"}

package/dist/helper/math.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.radiansToDegrees = exports.degreesToRadians = void 0;
+exports.randomRangeInt = randomRangeInt;
+function randomRangeInt(minInclude, maxExclude) {
+    return Math.round(Math.random() * (maxExclude - minInclude - 1)) + minInclude;
+}
+exports.degreesToRadians = cc.degreesToRadians;
+exports.radiansToDegrees = cc.radiansToDegrees;

package/dist/helper/utils.d.ts

@@ -0,0 +1,14 @@
+import { Constructor, EntityManager, EventManager, EventReceive } from 'entityx-ts';
+import { Collider, ComponentX, NoRenderComponentX, SceneComponent } from '..';
+export declare function registerSystem<T extends ComponentX>(component: Constructor<T>): {
+    new (): {
+        configure(event_manager: EventManager): void;
+        receive(type: string, event: EventReceive): void;
+        update(entities: EntityManager, events: EventManager, dt: number): void;
+    };
+};
+export type GetProps<T> = T extends ComponentX<infer P> ? P : T extends NoRenderComponentX<infer Q> ? Q : never;
+export declare function instantiate<T extends ComponentX>(ComponentType: Constructor<T>, data?: GetProps<T>): T;
+export declare function loadScene<T extends SceneComponent>(ComponentType: Constructor<T>): void;
+export declare function shouldCollider(colA: Collider, colB: Collider): any;
+//# sourceMappingURL=utils.d.ts.map

package/dist/helper/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/helper/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8C,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAU,MAAM,YAAY,CAAA;AAEvI,OAAO,EAAE,QAAQ,EAAiB,UAAU,EAAY,kBAAkB,EAAE,cAAc,EAAE,MAAM,IAAI,CAAA;AAGtG,wBAAgB,cAAc,CAAC,CAAC,SAAS,UAAU,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC;;iCAKjD,YAAY;sBAMvB,MAAM,SAAS,YAAY;yBAmBxB,aAAa,UAAU,YAAY,MAAM,MAAM;;EAenE;AAED,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,kBAAkB,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAE/G,wBAAgB,WAAW,CAAC,CAAC,SAAS,UAAU,EAAE,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAOtG;AACD,wBAAgB,SAAS,CAAC,CAAC,SAAS,cAAc,EAAE,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC,QAKhF;AACD,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,OAQ5D"}

package/dist/helper/utils.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSystem = registerSystem;
+exports.instantiate = instantiate;
+exports.loadScene = loadScene;
+exports.shouldCollider = shouldCollider;
+var entityx_ts_1 = require("entityx-ts");
+var __1 = require("..");
+var gworld_1 = require("../gworld");
+function registerSystem(component) {
+    if (gworld_1.GameWorld.Instance.systems.isRegistered("".concat(component.name, "System"))) {
+        return;
+    }
+    var NewSystem = /** @class */ (function () {
+        function NewSystem() {
+        }
+        NewSystem.prototype.configure = function (event_manager) {
+            console.log('configure registerSystem', component.name);
+            event_manager.subscribe((0, entityx_ts_1.ComponentAddedEvent)(component), this);
+            event_manager.subscribe((0, entityx_ts_1.ComponentRemovedEvent)(component), this);
+        };
+        NewSystem.prototype.receive = function (type, event) {
+            switch (type) {
+                case (0, entityx_ts_1.ComponentAddedEvent)(component): {
+                    var ett = event.entity;
+                    var newComp = event.component;
+                    newComp.node = ett.getComponent(__1.NodeComp);
+                    break;
+                }
+                case (0, entityx_ts_1.ComponentRemovedEvent)(component): {
+                    var newComp = event.component;
+                    if (newComp.destroy) {
+                        newComp.destroy();
+                    }
+                    break;
+                }
+                default:
+                    break;
+            }
+        };
+        NewSystem.prototype.update = function (entities, events, dt) {
+            for (var _i = 0, _a = entities.entities_with_components(component); _i < _a.length; _i++) {
+                var entt = _a[_i];
+                var comp = entt.getComponent(component);
+                // console.log('comp', comp.constructor.name, typeof comp['update'] === 'function')
+                if (comp.node.active && typeof comp['update'] === 'function') {
+                    comp['update'](dt);
+                }
+            }
+        };
+        return NewSystem;
+    }());
+    Object.defineProperty(NewSystem, 'name', { value: "".concat(component.name, "System") });
+    gworld_1.GameWorld.Instance.systems.add(NewSystem);
+    gworld_1.GameWorld.Instance.systems.configureOnce(NewSystem);
+    gworld_1.GameWorld.Instance.listUpdate.push(NewSystem);
+    return NewSystem;
+}
+function instantiate(ComponentType, data) {
+    var instance = new ComponentType(data);
+    instance.init(data);
+    if (!instance.render) {
+        return instance;
+    }
+    return instance.render();
+}
+function loadScene(ComponentType) {
+    var world = gworld_1.GameWorld.Instance;
+    world.entities.reset();
+    var instance = new ComponentType();
+    instance.render();
+}
+function shouldCollider(colA, colB) {
+    var groupA = colA.node.group;
+    var groupB = colB.node.group;
+    if (groupA === undefined || groupB === undefined) {
+        return true;
+    }
+    var colliderMatrix = gworld_1.GameWorld.Instance.systems.get(__1.CollideSystem).colliderMatrix;
+    return colliderMatrix[groupA][groupB];
+}

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export * from './app';
+export * from './dragonbones';
+export * from './gworld';
+export * from './gworld/components/CollideComponent';
+export * from './gworld/components/GUIComponent';
+export * from './gworld/components/NodeComp';
+export * from './gworld/components/NoRenderComponent';
+export * from './gworld/components/RenderComponent';
+export * from './gworld/core/decorator';
+export * from './gworld/core/Scene';
+export * from './gworld/systems/CollideSystem';
+export * from './helper/action';
+export * from './helper/director';
+export * from './helper/math';
+export * from './helper/NodePool';
+export * from './helper/utils';
+export * from './polyfills';
+export { type Touch } from './polyfills';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAA;AACrB,cAAc,eAAe,CAAA;AAC7B,cAAc,UAAU,CAAA;AACxB,cAAc,sCAAsC,CAAA;AACpD,cAAc,kCAAkC,CAAA;AAChD,cAAc,8BAA8B,CAAA;AAC5C,cAAc,uCAAuC,CAAA;AACrD,cAAc,qCAAqC,CAAA;AACnD,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,iBAAiB,CAAA;AAC/B,cAAc,mBAAmB,CAAA;AACjC,cAAc,eAAe,CAAA;AAC7B,cAAc,mBAAmB,CAAA;AACjC,cAAc,gBAAgB,CAAA;AAC9B,cAAc,aAAa,CAAA;AAC3B,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,aAAa,CAAA"}

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./app"), exports);
+__exportStar(require("./dragonbones"), exports);
+__exportStar(require("./gworld"), exports);
+__exportStar(require("./gworld/components/CollideComponent"), exports);
+__exportStar(require("./gworld/components/GUIComponent"), exports);
+__exportStar(require("./gworld/components/NodeComp"), exports);
+__exportStar(require("./gworld/components/NoRenderComponent"), exports);
+__exportStar(require("./gworld/components/RenderComponent"), exports);
+__exportStar(require("./gworld/core/decorator"), exports);
+__exportStar(require("./gworld/core/Scene"), exports);
+__exportStar(require("./gworld/systems/CollideSystem"), exports);
+__exportStar(require("./helper/action"), exports);
+__exportStar(require("./helper/director"), exports);
+__exportStar(require("./helper/math"), exports);
+__exportStar(require("./helper/NodePool"), exports);
+__exportStar(require("./helper/utils"), exports);
+__exportStar(require("./polyfills"), exports);

package/dist/polyfills.d.ts

@@ -0,0 +1,54 @@
+declare class _Vec2 {
+    x: number;
+    y: number;
+    static ZERO: any;
+    constructor(x?: number | object, y?: number);
+    equals(other: cc.Vec2): boolean;
+    add(value: cc.Point): cc.Vec2;
+    addSelf(value: cc.Point): cc.Vec2;
+    sub(value: cc.Point): cc.Vec2;
+    mul(multiply: number): cc.Vec2;
+    mulSelf(multiply: number): cc.Vec2;
+    mag(): number;
+    normalizeSelf(): cc.Vec2;
+    normalize(): cc.Vec2;
+    cross(other: Vec2): number;
+    signAngle(other: Vec2): number;
+    lengthSqr(): number;
+    dot(other: Vec2): number;
+    angle(other: Vec2): number;
+    distance(other: _Vec2): number;
+}
+export type Vec2 = _Vec2;
+export declare function Vec2(x?: number, y?: number): Vec2;
+export declare namespace Vec2 {
+    var ZERO: Readonly<_Vec2>;
+}
+export declare enum SpriteType {
+    SIMPLE = 0,
+    SLICED = 1,
+    TILED = 2,
+    FILLED = 3,
+    MESH = 4
+}
+export declare const RED: cc.Color;
+export declare const BLACK: cc.Color;
+export declare const WHITE: cc.Color;
+export declare const GREEN: cc.Color;
+export declare const BLUE: cc.Color;
+export declare function Color4B(r: number, g: number, b: number, a: number): cc.Color;
+export type Color4B = ReturnType<typeof Color4B>;
+declare class _Size {
+    width: number;
+    height: number;
+    static ZERO: any;
+    constructor(width?: number, height?: number);
+}
+export type Size = _Size;
+export declare function Size(x?: number, y?: number): Size;
+export declare class Touch extends cc.Touch {
+    getLocation: () => Vec2;
+}
+export declare function getWinSize(): Size;
+export {};
+//# sourceMappingURL=polyfills.d.ts.map

package/dist/polyfills.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyfills.d.ts","sourceRoot":"","sources":["../src/polyfills.ts"],"names":[],"mappings":"AAOA,cAAM,KAAK;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,MAAM,CAAC,IAAI,MAAA;gBACC,CAAC,GAAE,MAAM,GAAG,MAAU,EAAE,CAAC,SAAI;IAazC,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI;IAIrB,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,IAAI;IAI7B,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,IAAI;IAOjC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,EAAE,CAAC,IAAI;IAI7B,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,CAAC,IAAI;IAI9B,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,CAAC,IAAI;IAOlC,GAAG,IAAI,MAAM;IAIb,aAAa,IAAI,EAAE,CAAC,IAAI;IAOxB,SAAS,IAAI,EAAE,CAAC,IAAI;IAIb,KAAK,CAAC,KAAK,EAAE,IAAI;IAGjB,SAAS,CAAC,KAAK,EAAE,IAAI;IAIrB,SAAS;IAGT,GAAG,CAAC,KAAK,EAAE,IAAI;IAGf,KAAK,CAAC,KAAK,EAAE,IAAI;IAcjB,QAAQ,CAAC,KAAK,EAAE,KAAK;CAG7B;AACD,MAAM,MAAM,IAAI,GAAG,KAAK,CAAA;AACxB,wBAAgB,IAAI,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAEjD;yBAFe,IAAI;;;AAMpB,oBAAY,UAAU;IACpB,MAAM,IAAA;IACN,MAAM,IAAA;IACN,KAAK,IAAA;IACL,MAAM,IAAA;IACN,IAAI,IAAA;CACL;AAED,eAAO,MAAM,GAAG,UAA0B,CAAA;AAC1C,eAAO,MAAM,KAAK,UAAwB,CAAA;AAC1C,eAAO,MAAM,KAAK,UAA8B,CAAA;AAChD,eAAO,MAAM,KAAK,UAA0B,CAAA;AAC5C,eAAO,MAAM,IAAI,UAA0B,CAAA;AAY3C,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,YAEjE;AACD,MAAM,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAA;AAEhD,cAAM,KAAK;IACT,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,IAAI,MAAA;gBACC,KAAK,SAAI,EAAE,MAAM,SAAI;CAWlC;AAED,MAAM,MAAM,IAAI,GAAG,KAAK,CAAA;AACxB,wBAAgB,IAAI,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAEjD;AAED,qBAAa,KAAM,SAAQ,EAAE,CAAC,KAAK;IACzB,WAAW,EAAE,MAAM,IAAI,CAAA;CAChC;AAED,wBAAgB,UAAU,IAAI,IAAI,CAEjC"}