@cc-component/cc-core 1.3.0 → 1.3.2

package/assets/core/lib/ecs/.ecs.md

@@ -0,0 +1 @@
+Entity-Component-System 框架

package/assets/core/lib/ecs/ECS.ts

@@ -0,0 +1,329 @@
+import { ECSComp } from "./ECSComp";
+import { ECSEntity } from "./ECSEntity";
+import { ECSMatcher } from "./ECSMatcher";
+import { CompCtor, CompType, ECSModel, EntityCtor } from "./ECSModel";
+import { ECSComblockSystem, ECSRootSystem, ECSSystem } from "./ECSSystem";
+
+/** 
+ * ECSEntity对象在destroy后，会回收到ECSModel.entityPool实体对象池中
+ * ECSComp对象从ECSEntity.remove后，数据组件会回收到ECSModel.compPools组件对象池中
+ */
+
+/** 
+ * Entity-Component-System（实体-组件-系统）框架
+ * 文档：https://gitee.com/dgflash/oops-framework/wikis/pages?sort_id=12033388&doc_id=2873565
+ */
+export namespace ecs {
+    /** 实体 - 一个概念上的定义，指的是游戏世界中的一个独特物体，是一系列组件的集合 */
+    export type Entity = ECSEntity;
+    /** 组件 - 一堆数据的集合，即不存在任何的行为，只用来存储状态 */
+    export type Comp = ECSComp;
+    /** 系统 - 关注实体上组件数据变化，处理游戏逻辑 */
+    export type System = ECSSystem;
+    /** 根系统 - 驱动游戏中所有系统工作 */
+    export type RootSystem = ECSRootSystem;
+    /** 处理游戏逻辑系统对象 - 继承此对象实现自定义业务逻辑 */
+    export type ComblockSystem = ECSComblockSystem;
+
+    /** 实体 - 一个概念上的定义，指的是游戏世界中的一个独特物体，是一系列组件的集合 */
+    export const Entity = ECSEntity;
+    /** 组件 - 一堆数据的集合，即不存在任何的行为，只用来存储状态 */
+    export const Comp = ECSComp;
+    /** 系统 - 关注实体上组件数据变化，处理游戏逻辑 */
+    export const System = ECSSystem;
+    /** 根系统 - 驱动游戏中所有系统工作 */
+    export const RootSystem = ECSRootSystem;
+    /** 处理游戏逻辑系统对象 - 继承此对象实现自定义业务逻辑 */
+    export const ComblockSystem = ECSComblockSystem;
+
+    //#region 接口
+
+    /** 组件接口 */
+    export interface IComp {
+        canRecycle: boolean;
+        ent: Entity;
+        tid: number;
+
+        reset(): void;
+    }
+
+    /** 实体匹配器接口 */
+    export interface IMatcher {
+        mid: number;
+        indices: number[];
+        key: string;
+        isMatch(entity: Entity): boolean;
+    }
+
+    /**
+     * 监听组件首次添加到实体上时，在ComblockSystem上实现这个接口
+     * 1. entityEnter会在update方法之前执行，实体进入后，不会再次进入entityEnter方法中
+     * 2. 当实体从当前System移除，下次再次符合条件进入System也会执行上述流程
+     * @example
+    export class RoleUpgradeSystem extends ecs.ComblockSystem implements ecs.IEntityEnterSystem {
+        filter(): ecs.IMatcher {
+            return ecs.allOf(RoleUpgradeComp, RoleModelLevelComp);
+        }
+
+        entityEnter(e: Role): void {
+            e.remove(RoleUpgradeComp);
+        }
+    }
+     */
+    export interface IEntityEnterSystem<E extends Entity = Entity> {
+        entityEnter(entity: E): void;
+    }
+
+    /** 监听组件从实体上移除时，在ComblockSystem上实现这个接口 */
+    export interface IEntityRemoveSystem<E extends Entity = Entity> {
+        entityRemove(entity: E): void;
+    }
+
+    /** 监听系统第一次执行update处理实体时，在ComblockSystem上实现这个接口 */
+    export interface ISystemFirstUpdate<E extends Entity = Entity> {
+        firstUpdate(entity: E): void;
+    }
+
+    /** 监听系统执行update处理实体时，在ComblockSystem上实现这个接口 */
+    export interface ISystemUpdate<E extends Entity = Entity> {
+        update(entity: E): void;
+    }
+    //#endregion
+
+    /**
+     * 注册组件到ecs系统中
+     * @param name   由于js打包会改变类名，所以这里必须手动传入组件的名称
+     * @param canNew 标识是否可以new对象。想继承自Cocos Creator的组件就不能去new，需要写成@ecs.register('name', false)
+     * @example
+    // 注册实体
+    @ecs.register('Role')
+    export class Role extends ecs.Entity {
+
+    }
+
+    // 注册数据组件
+    @ecs.register('RoleModel')
+    export class RoleModelComp extends ecs.Comp {
+        id: number = -1;
+
+        reset() {
+            this.id =  -1;
+        }
+    }
+
+    // 注册系统组件
+    @ecs.register('Initialize')
+    export class InitResSystem extends ecs.ComblockSystem implements ecs.IEntityEnterSystem {
+
+    }
+
+    // 注册显示对象组件
+    @ccclass('RoleViewComp')
+    @ecs.register('RoleView', false)
+    export class RoleViewComp extends CCComp {
+        onLoad(){
+            
+        }
+    }
+    */
+    export function register<T>(name: string, canNew: boolean = true) {
+        return function (ctor: any) {
+            // 注册系统
+            if (ctor.s) {
+                var system = ECSModel.systems.get(name);
+                if (system == null) {
+                    system = new ecs.System();
+                    ECSModel.systems.set(name, system);
+                }
+                system.add(new ctor);
+            }
+            // 注册实体
+            else if (ctor.tid == undefined) {
+                ECSModel.entityCtors.set(ctor as EntityCtor<T>, name);
+            }
+            // 注册组件
+            else {
+                if (ctor.tid === -1) {
+                    ctor.tid = ECSModel.compTid++;
+                    ctor.compName = name;
+                    ECSModel.compCtors.push(ctor);              // 注册不同类型的组件
+                    if (canNew) {
+                        ECSModel.compPools.set(ctor.tid, []);
+                    }
+                    ECSModel.compAddOrRemove.set(ctor.tid, []);
+                }
+                else {
+                    throw new Error(`ECS 组件重复注册: ${name}.`);
+                }
+            }
+        }
+    }
+
+    /**
+     * 创建一个新的实体对象或从缓存中获取一个实体对象
+     * @param ctor 实体类
+     */
+    export function getEntity<T extends Entity>(ctor: EntityCtor<T>): T {
+        // 获取实体对象名
+        var entityName = ECSModel.entityCtors.get(ctor);
+        if (entityName == undefined)
+            console.error(`${ctor.name} 实体没有注册`);
+
+        // 获取实体对象池
+        var entitys = ECSModel.entityPool.get(entityName!) || [];
+        var entity: any = entitys.pop();
+
+        // 缓存中没有同类实体，则创建一个新的
+        if (!entity) {
+            entity = new ctor();
+            entity.eid = ECSModel.eid++;        // 实体唯一编号
+            entity.name = entityName;
+        }
+
+        // 触发实体初始化逻辑
+        if (entity.init) {
+            entity.isValid = true;
+            entity.init();
+        }
+        else
+            console.error(`${ctor.name} 实体缺少 init 方法初始化默认组件`);
+
+        ECSModel.eid2Entity.set(entity.eid, entity);
+        return entity as T;
+    }
+
+    /**
+     * 动态查询实体
+     * @param matcher 匹配器
+     * @example
+     * ecs.query(ecs.allOf(Comp1, Comp2));
+     */
+    export function query<E extends Entity = Entity>(matcher: IMatcher): E[] {
+        let group = ECSModel.groups.get(matcher.mid);
+        if (!group) {
+            group = ECSModel.createGroup(matcher);
+            ECSModel.eid2Entity.forEach(group.onComponentAddOrRemove, group);
+        }
+        return group.matchEntities as E[];
+    }
+
+    /** 清理所有的实体 */
+    export function clear() {
+        ECSModel.eid2Entity.forEach((entity) => {
+            entity.destroy();
+        });
+        ECSModel.groups.forEach((group) => {
+            group.clear();
+        });
+        ECSModel.compAddOrRemove.forEach(callbackLst => {
+            callbackLst.length = 0;
+        });
+        ECSModel.eid2Entity.clear();
+        ECSModel.groups.clear();
+    }
+
+    /**
+     * 通过实体唯一编号获得实体对象
+     * @param eid 实体唯一编号
+     */
+    export function getEntityByEid<E extends Entity = Entity>(eid: number): E {
+        return ECSModel.eid2Entity.get(eid) as E;
+    }
+
+    /** 当前活动中的实体数量 */
+    export function activeEntityCount() {
+        return ECSModel.eid2Entity.size;
+    }
+
+    /** 创建实体 */
+    function createEntity<E extends Entity = Entity>(): E {
+        let entity = new Entity();
+        entity.eid = ECSModel.eid++;                     // 实体id也是有限的资源
+        ECSModel.eid2Entity.set(entity.eid, entity);
+        return entity as E;
+    }
+
+    /**
+     * 指定一个组件创建实体，返回组件对象。
+     * @param ctor 
+     */
+    function createEntityWithComp<T extends IComp>(ctor: CompCtor<T>): T {
+        let entity = createEntity();
+        return entity.add(ctor);
+    }
+
+    //#region 过滤器
+    /**
+     * 表示只关心这些组件的添加和删除动作。虽然实体可能有这些组件之外的组件，但是它们的添加和删除没有被关注，所以不会存在对关注之外的组件
+     * 进行添加操作引发Group重复添加实体。
+     * @param args 
+     * @example
+     * ecs.allOf(AComponent, BComponent, CComponent);
+     */
+    export function allOf(...args: CompType<IComp>[]) {
+        return new ECSMatcher().allOf(...args);
+    }
+
+    /**
+     * 组件间是或的关系，表示关注拥有任意一个这些组件的实体
+     * @param args  组件类
+     * @example
+     * ecs.anyOf(AComponent, BComponent);
+     */
+    export function anyOf(...args: CompType<IComp>[]) {
+        return new ECSMatcher().anyOf(...args);
+    }
+
+    /**
+     * 表示关注只拥有这些组件的实体
+     * 注：不是特殊情况不建议使用onlyOf。因为onlyOf会监听所有组件的添加和删除事件
+     * @param args  组件类
+     * @example
+     // 不包含CComponent或者DComponent
+     ecs.allOf(AComponent, BComponent).excludeOf(CComponent, DComponent);
+
+     // 不同时包含CComponent和DComponent
+     ecs.allOf(AComponent, BComponent).excludeOf(CComponent).excludeOf(DComponent);
+     */
+    export function onlyOf(...args: CompType<IComp>[]) {
+        return new ECSMatcher().onlyOf(...args);
+    }
+
+    /**
+     * 不包含指定的任意一个组件
+     * @param args  组件类
+     * @example
+     // 表示不包含组件A或者组件B
+     ecs.excludeOf(A, B); 
+     */
+    export function excludeOf(...args: CompType<IComp>[]) {
+        return new ECSMatcher().excludeOf(...args);
+    }
+    //#endregion
+
+    //#region 单例组件
+    /**
+     * 获取单例组件
+     * @param ctor 组件类
+     */
+    export function getSingleton<T extends IComp>(ctor: CompCtor<T>) {
+        if (!ECSModel.tid2comp.has(ctor.tid)) {
+            let comp = createEntityWithComp(ctor) as T;
+            ECSModel.tid2comp.set(ctor.tid, comp);
+        }
+        return ECSModel.tid2comp.get(ctor.tid) as T;
+    }
+
+    /**
+     * 注册单例组件 - 主要用于那些不能手动创建对象的组件
+     * @param obj 
+     */
+    export function addSingleton(obj: IComp) {
+        let tid = (obj.constructor as CompCtor<IComp>).tid;
+        if (!ECSModel.tid2comp.has(tid)) {
+            ECSModel.tid2comp.set(tid, obj);
+        }
+    }
+
+    //#endregion
+}

package/assets/core/{home/BaseBoxView.ts.meta → lib/ecs/ECS.ts.meta}

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "637b836b-f10e-4080-a899-94b147fda6c7",
+  "uuid": "be87f4fb-ea99-4b91-a50a-118a64b95d27",
   "files": [],
   "subMetas": {},
   "userData": {}

package/assets/core/lib/ecs/ECSComp.ts

@@ -0,0 +1,35 @@
+/*
+ * @Author: dgflash
+ * @Date: 2022-09-01 18:00:28
+ * @LastEditors: dgflash
+ * @LastEditTime: 2022-09-05 14:03:54
+ */
+import { ecs } from "./ECS";
+import { ECSEntity } from "./ECSEntity";
+
+/** 
+ * 组件抽象类
+ * 注：建议组件里面只放数据可能在实际写代码会碰到一些比较麻烦的问题，如果是单纯对组件内的数据操作可以在组件里面写方法
+ */
+export abstract class ECSComp implements ecs.IComp {
+    /** 组件的类型编号，-1表示未给该组件分配编号 */
+    static tid: number = -1;
+    /** 组件名 */
+    static compName: string;
+
+    /**
+     * 是否可回收组件对象，默认情况下都是可回收的
+     * 注：如果该组件对象是由ecs系统外部创建的，则不可回收，需要用户自己手动进行回收
+     */
+    canRecycle: boolean = true;
+    /** 拥有该组件的实体 */
+    ent!: ECSEntity;
+    /** 组件的类型编号 */
+    tid: number = -1;
+
+    /**
+     * 组件被回收时会调用这个接口。可以在这里重置数据，或者解除引用
+     * 注：不要偷懒，除非你能确定并保证组件在复用时，里面的数据是先赋值然后再使用
+     */
+    abstract reset(): void;
+}

package/assets/core/{home/DouYinShow.ts.meta → lib/ecs/ECSComp.ts.meta}

@@ -2,7 +2,7 @@
   "ver": "4.0.24",
   "importer": "typescript",
   "imported": true,
-  "uuid": "451fbb21-03ed-458c-a98d-a76ead2c9082",
+  "uuid": "3d017661-0194-47e1-b3df-a4baf9fbef05",
   "files": [],
   "subMetas": {},
   "userData": {}

package/assets/core/lib/ecs/ECSEntity.ts

@@ -0,0 +1,302 @@
+import { ecs } from "./ECS";
+import { ECSMask } from "./ECSMask";
+import { CompCtor, CompType, ECSModel } from "./ECSModel";
+
+//#region 辅助方法
+
+/**
+ * 实体身上组件有增删操作，广播通知对应的观察者
+ * @param entity 实体对象
+ * @param componentTypeId 组件类型id
+ */
+function broadcastCompAddOrRemove(entity: ECSEntity, componentTypeId: number) {
+    let events = ECSModel.compAddOrRemove.get(componentTypeId);
+    for (let i = events!.length - 1; i >= 0; i--) {
+        events![i](entity);
+    }
+    // 判断是不是删了单例组件
+    if (ECSModel.tid2comp.has(componentTypeId)) {
+        ECSModel.tid2comp.delete(componentTypeId);
+    }
+}
+
+/**
+ * 创建组件对象
+ * @param ctor
+ */
+function createComp<T extends ecs.IComp>(ctor: CompCtor<T>): T {
+    const cct = ECSModel.compCtors[ctor.tid];
+    if (!cct) {
+        throw Error(`没有找到该组件的构造函数，检查${ctor.compName}是否为不可构造的组件`);
+    }
+    let comps = ECSModel.compPools.get(ctor.tid)!;
+    let component = comps.pop() || new (cct as CompCtor<T>);
+    return component as T;
+}
+
+/**
+ * 销毁实体
+ * 
+ * 缓存销毁的实体，下次新建实体时会优先从缓存中拿
+ * @param entity 
+ */
+function destroyEntity(entity: ECSEntity) {
+    if (ECSModel.eid2Entity.has(entity.eid)) {
+        let entitys = ECSModel.entityPool.get(entity.name);
+        if (entitys == null) {
+            entitys = [];
+            ECSModel.entityPool.set(entity.name, entitys);
+        }
+        entitys.push(entity);
+        ECSModel.eid2Entity.delete(entity.eid);
+    }
+    else {
+        console.warn('试图销毁不存在的实体');
+    }
+}
+
+//#endregion
+
+/** ECS实体对象 */
+export class ECSEntity {
+    /** 实体唯一标识，不要手动修改 */
+    eid: number = -1;
+    /** 实体对象名 */
+    name: string = "";
+    /** 实体是否有效 */
+    isValid: boolean = true;
+    /** 组件过滤数据 */
+    private mask = new ECSMask();
+    /** 当前实体身上附加的组件构造函数 */
+    private compTid2Ctor: Map<number, CompType<ecs.IComp>> = new Map();
+    /** 配合 entity.remove(Comp, false)， 记录组件实例上的缓存数据，在添加时恢复原数据 */
+    private compTid2Obj: Map<number, ecs.IComp> = new Map();
+
+    private _parent: ECSEntity | null = null;
+    /** 父实体 */
+    get parent(): ECSEntity | null {
+        return this._parent;
+    }
+    set parent(value: ECSEntity | null) {
+        this._parent = value;
+    }
+
+    /** 子实体 */
+    private childs: Map<number, ECSEntity> = null!;
+
+    /** 获取子实体 */
+    getChild<T>(eid: number) {
+        return this.childs.get(eid) as T;
+    }
+
+    /**
+     * 添加子实体
+     * @param entity 被添加的实体对象
+     * @returns      子实体的唯一编号, -1表示添加失败
+     */
+    addChild(entity: ECSEntity): number {
+        if (this.childs == null) this.childs = new Map<number, ECSEntity>();
+
+        if (this.childs.has(entity.eid)) {
+            console.warn(`子实体${entity.name}已存在`);
+            return -1;
+        }
+
+        entity._parent = this;
+        this.childs.set(entity.eid, entity);
+        return entity.eid;
+    }
+
+    /**
+     * 移除子实体
+     * @param entity    被移除的实体对象
+     * @param isDestroy 被移除的实体是否释放，默认为释放
+     * @returns 
+     */
+    removeChild(entity: ECSEntity, isDestroy = true) {
+        if (this.childs == null) return;
+
+        entity.parent = null;
+        this.childs.delete(entity.eid);
+        if (isDestroy) entity.destroy();
+    }
+
+    /**
+     * 根据组件类动态创建组件，并通知关心的系统。如果实体存在了这个组件，那么会先删除之前的组件然后添加新的
+     * 
+     * 注意：不要直接new Component，new来的Component不会从Component的缓存池拿缓存的数据
+     * @param componentTypeId   组件类
+     * @param isReAdd           true-表示用户指定这个实体可能已经存在了该组件，那么再次add组件的时候会先移除该组件然后再添加一遍。false-表示不重复添加组件
+     */
+    add<T extends ecs.IComp>(obj: T): ECSEntity;
+    add<T extends ecs.IComp>(ctor: CompType<T>, isReAdd?: boolean): T;
+    add<T extends ecs.IComp>(ctor: CompType<T> | T, isReAdd: boolean = false): T | ECSEntity {
+        if (typeof ctor === 'function') {
+            let compTid = ctor.tid;
+            if (ctor.tid === -1) {
+                throw Error(`【${this.name}】实体【${ctor.compName}】组件未注册`);
+            }
+            if (this.compTid2Ctor.has(compTid)) {                               // 判断是否有该组件，如果有则先移除
+                if (isReAdd) {
+                    this.remove(ctor);
+                }
+                else {
+                    console.log(`【${this.name}】实体【${ctor.compName}】组件已存在`);
+                    // @ts-ignore
+                    return this[ctor.compName] as T;
+                }
+            }
+            this.mask.set(compTid);
+
+            let comp: T;
+            if (this.compTid2Obj.has(compTid)) {
+                comp = this.compTid2Obj.get(compTid) as T;
+                this.compTid2Obj.delete(compTid);
+            }
+            else {
+                // 创建组件对象
+                comp = createComp(ctor) as T;
+            }
+
+            // 将组件对象直接附加到实体对象身上，方便直接获取
+            // @ts-ignore
+            this[ctor.compName] = comp;
+            this.compTid2Ctor.set(compTid, ctor);
+            comp.tid = compTid;
+            comp.ent = this;
+            // 广播实体添加组件的消息
+            broadcastCompAddOrRemove(this, compTid);
+
+            return comp;
+        }
+        else {
+            let tmpCtor = (ctor.constructor as CompCtor<T>);
+            let compTid = tmpCtor.tid;
+            // console.assert(compTid !== -1 || !compTid, '组件未注册！');
+            // console.assert(this.compTid2Ctor.has(compTid), '已存在该组件！');
+            if (compTid === -1 || compTid == null) throw Error(`【${this.name}】实体【${tmpCtor.name}】组件未注册`);
+            if (this.compTid2Ctor.has(compTid)) throw Error(`【${this.name}】实体【${tmpCtor.name}】组件已经存在`);
+
+            this.mask.set(compTid);
+            //@ts-ignore
+            this[tmpCtor.compName] = ctor;
+            this.compTid2Ctor.set(compTid, tmpCtor);
+            //@ts-ignore
+            ctor.tid = compTid;
+            //@ts-ignore
+            ctor.canRecycle = false;
+            //@ts-ignore
+            ctor.ent = this;
+            broadcastCompAddOrRemove(this, compTid);
+
+            return this;
+        }
+    }
+
+    /**
+     * 批量添加组件
+     * @param ctors 组件类
+     * @returns 
+     */
+    addComponents<T extends ecs.IComp>(...ctors: CompType<T>[]) {
+        for (let ctor of ctors) {
+            this.add(ctor);
+        }
+        return this;
+    }
+
+    /**
+     * 获取一个组件实例
+     * @param ctor 组件类
+     */
+    get(ctor: number): number;
+    get<T extends ecs.IComp>(ctor: CompCtor<T>): T;
+    get<T extends ecs.IComp>(ctor: CompCtor<T> | number): T {
+        // @ts-ignore
+        return this[ctor.compName];
+    }
+
+    /**
+     * 组件是否在实体存在内
+     * @param ctor 组件类
+     */
+    has(ctor: CompType<ecs.IComp>): boolean {
+        if (typeof ctor == "number") {
+            return this.mask.has(ctor);
+        }
+        else {
+            return this.compTid2Ctor.has(ctor.tid);
+        }
+    }
+
+    /**
+     * 从实体上删除指定组件
+     * @param ctor      组件构造函数或者组件Tag
+     * @param isRecycle 是否回收该组件对象。对于有些组件上有大量数据，当要描述移除组件但是不想清除组件上的数据是可以
+     * 设置该参数为false，这样该组件对象会缓存在实体身上，下次重新添加组件时会将该组件对象添加回来，不会重新从组件缓存
+     * 池中拿一个组件来用。
+     */
+    remove(ctor: CompType<ecs.IComp>, isRecycle: boolean = true) {
+        let hasComp = false;
+        //@ts-ignore
+        let componentTypeId = ctor.tid;
+        //@ts-ignore
+        let compName = ctor.compName;
+        if (this.mask.has(componentTypeId)) {
+            hasComp = true;
+            //@ts-ignore
+            let comp = this[ctor.compName];
+            //@ts-ignore
+            comp.ent = null;
+            if (isRecycle) {
+                comp.reset();
+
+                // 回收组件到指定缓存池中
+                if (comp.canRecycle) {
+                    const compPoolsType = ECSModel.compPools.get(componentTypeId)!;
+                    compPoolsType.push(comp);
+                }
+            }
+            else {
+                this.compTid2Obj.set(componentTypeId, comp);        // 用于缓存显示对象组件
+            }
+        }
+
+        // 删除实体上的组件逻辑
+        if (hasComp) {
+            //@ts-ignore
+            this[compName] = null;
+            this.mask.delete(componentTypeId);
+            this.compTid2Ctor.delete(componentTypeId);
+            broadcastCompAddOrRemove(this, componentTypeId);
+        }
+    }
+
+    /** 销毁实体，实体会被回收到实体缓存池中 */
+    destroy() {
+        this.isValid = false;
+
+        // 如果有父模块，则移除父模块上记录的子模块
+        if (this._parent) {
+            this._parent.removeChild(this, false);
+            this._parent = null;
+        }
+
+        // 移除模块上所有子模块
+        if (this.childs) {
+            this.childs.forEach(e => {
+                this.removeChild(e);
+            });
+            this.childs = null!;
+        }
+
+        // 移除实体上所有组件
+        this.compTid2Ctor.forEach(this._remove, this);
+        destroyEntity(this);
+        this.compTid2Obj.clear();
+    }
+
+    private _remove(comp: CompType<ecs.IComp>) {
+        this.remove(comp, true);
+    }
+}

package/assets/core/lib/ecs/ECSEntity.ts.meta

@@ -0,0 +1,9 @@
+{
+  "ver": "4.0.24",
+  "importer": "typescript",
+  "imported": true,
+  "uuid": "1fb62582-dcf6-4fbc-b863-a1941fad1109",
+  "files": [],
+  "subMetas": {},
+  "userData": {}
+}