@gby/destroyable 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 郭斌勇
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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.

package/README.md

@@ -0,0 +1,101 @@
+[教程]: ./doc/教程.md
+[API接口文档]: ./doc/api/index.md
+
+[GitHub仓库]: https://github.com/GuoBinyong/destroyable
+[发行地址]: https://github.com/GuoBinyong/destroyable/releases
+[issues]: https://github.com/GuoBinyong/destroyable/issues
+
+[码云仓库]: https://gitee.com/guobinyong/destroyable
+
+
+
+**目录**  
+
+<!-- @import "[TOC]" {cmd="toc" depthFrom=1 depthTo=6 orderedList=false} -->
+
+<!-- code_chunk_output -->
+
+- [1. 背景](#1-背景)
+- [2. 简介](#2-简介)
+- [3. 安装方式](#3-安装方式)
+  - [3.1. 方式1：通过 npm 安装](#31-方式1通过-npm-安装)
+  - [3.2. 方式3：通过`<script>`标签引入](#32-方式3通过script标签引入)
+- [4. 教程](#4-教程)
+- [5. API接口文档](#5-api接口文档)
+
+<!-- /code_chunk_output -->
+
+
+---------------------
+
+
+# 1. 背景
+
+# 2. 简介
+库的简单介绍
+
+**具有以下特性：**  
+- 特性1
+- 特性2
+- 特性3
+
+**详情请看：**  
+- 主页：<https://github.com/GuoBinyong/destroyable>
+- [GitHub仓库][]
+- [码云仓库][]
+- [教程][]
+- [API接口文档][]
+
+
+**如果您在使用的过程中遇到了问题，或者有好的建议和想法，您都可以通过以下方式联系我，期待与您的交流：**
+- 给该仓库提交 [issues][]
+- 给我 Pull requests
+- 邮箱：<guobinyong@qq.com>
+- 微信：keyanzhe
+
+
+
+
+
+# 3. 安装方式
+目前，安装方式有以下几种：
+
+
+## 3.1. 方式1：通过 npm 安装
+通过 npm （或 yarn、pnpm 等包管理器）安装
+```shell
+npm install destroyable
+```
+
+
+
+
+## 3.2. 方式3：通过`<script>`标签引入
+您可直接从项目的 [发行地址][] 中下载以 `.iife.js` 作为缀的文件，然后使用如下代码引用 和 使用 destroyable：
+
+
+1. 引用 destroyable
+   ```html
+   <script src="path/to/package/destroyable.iife.js"></script>
+   ```
+   
+2. 使用全局的 `LibraryViteTemplate`
+   ```html
+   <script>
+   // 使用全局的 LibraryViteTemplate
+   </script>
+   ```
+
+# 4. 教程
+详情跳转至[教程][]
+
+# 5. API接口文档
+详情跳转至[API接口文档][]
+
+
+
+--------------------
+
+> 有您的支持，我会在开源的道路上，越走越远
+
+![赞赏码](https://i.loli.net/2020/04/08/PGsAEqdJCin1oQL.jpg)

package/dist/Destroyable.d.ts

@@ -0,0 +1,257 @@
+/**
+ * 可销毁的
+ *
+ * @remarks
+ * @gby/destroyable 提供了用于构建可销毁对象的类的基类，用于使得地管理可销毁对象的生命周期
+ *
+ * @packageDocumentation
+ */
+
+import { EventBus } from '@gby/event-bus';
+import { EventEmitter } from 'node:events';
+import { FunDestroyer as FunDestroyer_2 } from './Destroyable';
+
+/**
+ * 创建可销毁的子类
+ * @remarks
+ * 用于根据传入的父类 动态生成可可销毁的子类
+ * @param ParentClass
+ * @returns
+ */
+export declare function createDestroyableSubClass<P extends new (...args: any) => any>(ParentClass: P): {
+    new (...args: any): {
+        [x: string]: any;
+        /**
+         * 是否已经销毁
+         */
+        readonly isDestroyed: boolean;
+        _isDestroyed: boolean;
+        /**
+         * 销毁者
+         */
+        _destroyers: FunDestroyer[];
+        /**
+         * 添加销毁者
+         * @param fun
+         * @returns 返回销毁者的顺序
+         */
+        disposeFun<T extends FunDestroyer>(fun: T): T;
+        /**
+         * 取消销毁者函数
+         * @param fun
+         * @returns
+         */
+        cancelDisposeFun<T extends FunDestroyer>(fun: T): T;
+        /**
+         * 添加销毁对象
+         * @param obj
+         * @param sync - 表示是否使用  `obj.destroy()` 方法进行销毁；默认使用   `obj.destroyAsync()` 方法进行销毁
+         * @returns
+         */
+        disposeObj<T extends /*elided*/ any>(obj: T, sync?: boolean): T;
+        /**
+         * 取消销毁者函数
+         * @param fun
+         * @returns
+         */
+        cancelDisposeObj<T extends /*elided*/ any>(obj: T): T;
+        /**
+         * 添加销毁函数或销毁对象
+         * @param fun
+         */
+        dispose<T extends FunDestroyer>(fun: T): T;
+        dispose<T extends /*elided*/ any>(obj: T, asyncDestroy?: boolean): T;
+        dispose<T extends /*elided*/ any | FunDestroyer>(objOrFun: T, asyncDestroy?: boolean): T;
+        cancelDispose<T extends FunDestroyer>(fun: T): T;
+        cancelDispose<T extends /*elided*/ any>(obj: T): T;
+        cancelDispose<T extends /*elided*/ any | FunDestroyer>(objOrFun: T): T;
+        /**
+         * 自己的销毁方法
+         * @remarks
+         * 子类根据需要进行重载
+         */
+        destroyThis(): void;
+        /**
+         * 销毁
+         */
+        destroy(): true | undefined;
+        /**
+         * 异步销毁
+         * @remarks
+         * 会依次执行销毁，并且只有上一个销毁完成之后才会执行下一个销毁
+         */
+        destroyAsync(): Promise<true | undefined>;
+    };
+} & P;
+
+/**
+ * 可销毁的对象
+ */
+export declare class Destroyable {
+    /**
+     * 是否已经销毁
+     */
+    get isDestroyed(): boolean;
+    _isDestroyed: boolean;
+    /**
+     * 销毁者
+     */
+    _destroyers: FunDestroyer[];
+    /**
+     * 添加销毁者
+     * @param fun
+     * @returns 返回销毁者的顺序
+     */
+    disposeFun<T extends FunDestroyer>(fun: T): T;
+    /**
+     * 取消销毁者函数
+     * @param fun
+     * @returns
+     */
+    cancelDisposeFun<T extends FunDestroyer>(fun: T): T;
+    /**
+     * 添加销毁对象
+     * @param obj
+     * @param sync - 表示是否使用  `obj.destroy()` 方法进行销毁；默认使用   `obj.destroyAsync()` 方法进行销毁
+     * @returns
+     */
+    disposeObj<T extends Destroyable>(obj: T, sync?: boolean): T;
+    /**
+     * 取消销毁者函数
+     * @param fun
+     * @returns
+     */
+    cancelDisposeObj<T extends Destroyable>(obj: T): T;
+    /**
+     * 添加销毁函数或销毁对象
+     * @param fun
+     */
+    dispose<T extends FunDestroyer>(fun: T): T;
+    dispose<T extends Destroyable>(obj: T, asyncDestroy?: boolean): T;
+    dispose<T extends Destroyable | FunDestroyer>(objOrFun: T, asyncDestroy?: boolean): T;
+    cancelDispose<T extends FunDestroyer>(fun: T): T;
+    cancelDispose<T extends Destroyable>(obj: T): T;
+    cancelDispose<T extends Destroyable | FunDestroyer>(objOrFun: T): T;
+    /**
+     * 自己的销毁方法
+     * @remarks
+     * 子类根据需要进行重载
+     */
+    destroyThis(): void;
+    /**
+     * 销毁
+     */
+    destroy(): true | undefined;
+    /**
+     * 异步销毁
+     * @remarks
+     * 会依次执行销毁，并且只有上一个销毁完成之后才会执行下一个销毁
+     */
+    destroyAsync(): Promise<true | undefined>;
+}
+
+/**
+ * createDestroyableSubClass 创建的类的实例类型
+ */
+export declare type DestroyableSub<ParentClass extends new (...args: any) => any> = InstanceType<DestroyableSubClass<ParentClass>>;
+
+/**
+ * createDestroyableSubClass 创建的类的类型
+ */
+export declare type DestroyableSubClass<ParentClass extends new (...args: any) => any> = ReturnType<typeof createDestroyableSubClass<ParentClass>>;
+
+/**
+ * 销毁 Destroyable 对象
+ * @param object
+ * @returns
+ */
+export declare function destroyDestroyable(object: Destroyable): boolean;
+
+/**
+ * 销毁对象
+ * @param object
+ * @returns
+ */
+export declare function destroyObject(object: any): boolean;
+
+/**
+ * 函数销毁者
+ */
+export declare type FunDestroyer = () => void;
+
+/**
+ * NodeDestroyable 类对象
+ */
+export declare const NodeDestroyable: {
+    new (...args: any): {
+        [x: string]: any;
+        readonly isDestroyed: boolean;
+        _isDestroyed: boolean;
+        _destroyers: FunDestroyer_2[];
+        disposeFun<T extends FunDestroyer_2>(fun: T): T;
+        cancelDisposeFun<T extends FunDestroyer_2>(fun: T): T;
+        disposeObj<T extends /*elided*/ any>(obj: T, sync?: boolean): T;
+        cancelDisposeObj<T extends /*elided*/ any>(obj: T): T;
+        dispose<T extends FunDestroyer_2>(fun: T): T;
+        dispose<T extends /*elided*/ any>(obj: T, asyncDestroy?: boolean): T;
+        dispose<T extends FunDestroyer_2 | /*elided*/ any>(objOrFun: T, asyncDestroy?: boolean): T;
+        cancelDispose<T extends FunDestroyer_2>(fun: T): T;
+        cancelDispose<T extends /*elided*/ any>(obj: T): T;
+        cancelDispose<T extends FunDestroyer_2 | /*elided*/ any>(objOrFun: T): T;
+        destroyThis(): void;
+        destroy(): true | undefined;
+        destroyAsync(): Promise<true | undefined>;
+    };
+} & typeof EventEmitter;
+
+/**
+ * NodeDestroyable 实例的类型
+ */
+export declare type NodeDestroyable = InstanceType<NodeDestroyableClass>;
+
+/**
+ * NodeDestroyable 类的类型
+ */
+export declare type NodeDestroyableClass = typeof NodeDestroyable;
+
+/**
+ * 调用已销对象的时抛出错误
+ */
+export declare function throwOnDestroyed(): void;
+
+/**
+ * WebDestroyable 类对象
+ */
+export declare const WebDestroyable: {
+    new (...args: any): {
+        [x: string]: any;
+        readonly isDestroyed: boolean;
+        _isDestroyed: boolean;
+        _destroyers: FunDestroyer_2[];
+        disposeFun<T extends FunDestroyer_2>(fun: T): T;
+        cancelDisposeFun<T extends FunDestroyer_2>(fun: T): T;
+        disposeObj<T extends /*elided*/ any>(obj: T, sync?: boolean): T;
+        cancelDisposeObj<T extends /*elided*/ any>(obj: T): T;
+        dispose<T extends FunDestroyer_2>(fun: T): T;
+        dispose<T extends /*elided*/ any>(obj: T, asyncDestroy?: boolean): T;
+        dispose<T extends FunDestroyer_2 | /*elided*/ any>(objOrFun: T, asyncDestroy?: boolean): T;
+        cancelDispose<T extends FunDestroyer_2>(fun: T): T;
+        cancelDispose<T extends /*elided*/ any>(obj: T): T;
+        cancelDispose<T extends FunDestroyer_2 | /*elided*/ any>(objOrFun: T): T;
+        destroyThis(): void;
+        destroy(): true | undefined;
+        destroyAsync(): Promise<true | undefined>;
+    };
+} & typeof EventBus;
+
+/**
+ * WebDestroyable 实例的类型
+ */
+export declare type WebDestroyable = InstanceType<WebDestroyableClass>;
+
+/**
+ * WebDestroyable 类的类型
+ */
+export declare type WebDestroyableClass = typeof WebDestroyable;
+
+export { }

package/dist/Destroyable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Destroyable.d.ts","sourceRoot":"","sources":["../src/Destroyable.ts"],"names":[],"mappings":"AACA;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC;AAGtC;;GAEG;AACH,qBAAa,WAAW;IAEpB;;OAEG;IACH,IAAI,WAAW,YAEd;IACD,YAAY,UAAS;IAErB;;OAEG;IACH,WAAW,EAAE,YAAY,EAAE,CAAM;IAEjC;;;;OAIG;IACH,UAAU,CAAC,CAAC,SAAS,YAAY,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC;IAK7C;;;;OAIG;IACH,gBAAgB,CAAC,CAAC,SAAS,YAAY,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC;IAMnD;;;;;OAKG;IACH,UAAU,CAAC,CAAC,SAAS,WAAW,EAAE,GAAG,EAAE,CAAC,EAAC,IAAI,CAAC,EAAC,OAAO,GAAG,CAAC;IAQ1D;;;;OAIG;IACH,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC;IASlD;;;OAGG;IACH,OAAO,CAAC,CAAC,SAAS,YAAY,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC;IAC1C,OAAO,CAAC,CAAC,SAAS,WAAW,EAAE,GAAG,EAAE,CAAC,EAAC,YAAY,CAAC,EAAC,OAAO,GAAG,CAAC;IAC/D,OAAO,CAAC,CAAC,SAAS,WAAW,GAAG,YAAY,EAAE,QAAQ,EAAE,CAAC,EAAC,YAAY,CAAC,EAAC,OAAO,GAAG,CAAC;IASnF,aAAa,CAAC,CAAC,SAAS,YAAY,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC;IAChD,aAAa,CAAC,CAAC,SAAS,WAAW,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC;IAC/C,aAAa,CAAC,CAAC,SAAS,WAAW,GAAG,YAAY,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC;IAcnE;;;;OAIG;IACH,WAAW;IAKX;;OAEG;IACH,OAAO;IAiBP;;;;OAIG;IACG,YAAY;CAmBrB;AAOD;;GAEG;AACH,wBAAgB,gBAAgB,SAE/B;AAKD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,GAAG,WASxC;AAKD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,WAAW,WAYrD"}

package/dist/DestroyableSub.d.ts

@@ -0,0 +1,67 @@
+import { EventBus } from "@gby/event-bus";
+import { EventEmitter } from "node:events";
+/**
+ * WebDestroyable 类对象
+ */
+export declare const WebDestroyable: {
+    new (...args: any): {
+        [x: string]: any;
+        readonly isDestroyed: boolean;
+        _isDestroyed: boolean;
+        _destroyers: import("./Destroyable").FunDestroyer[];
+        disposeFun<T extends import("./Destroyable").FunDestroyer>(fun: T): T;
+        cancelDisposeFun<T extends import("./Destroyable").FunDestroyer>(fun: T): T;
+        disposeObj<T extends /*elided*/ any>(obj: T, sync?: boolean): T;
+        cancelDisposeObj<T extends /*elided*/ any>(obj: T): T;
+        dispose<T extends import("./Destroyable").FunDestroyer>(fun: T): T;
+        dispose<T extends /*elided*/ any>(obj: T, asyncDestroy?: boolean): T;
+        dispose<T extends import("./Destroyable").FunDestroyer | /*elided*/ any>(objOrFun: T, asyncDestroy?: boolean): T;
+        cancelDispose<T extends import("./Destroyable").FunDestroyer>(fun: T): T;
+        cancelDispose<T extends /*elided*/ any>(obj: T): T;
+        cancelDispose<T extends import("./Destroyable").FunDestroyer | /*elided*/ any>(objOrFun: T): T;
+        destroyThis(): void;
+        destroy(): true | undefined;
+        destroyAsync(): Promise<true | undefined>;
+    };
+} & typeof EventBus;
+/**
+ * WebDestroyable 类的类型
+ */
+export type WebDestroyableClass = typeof WebDestroyable;
+/**
+ * WebDestroyable 实例的类型
+ */
+export type WebDestroyable = InstanceType<WebDestroyableClass>;
+/**
+ * NodeDestroyable 类对象
+ */
+export declare const NodeDestroyable: {
+    new (...args: any): {
+        [x: string]: any;
+        readonly isDestroyed: boolean;
+        _isDestroyed: boolean;
+        _destroyers: import("./Destroyable").FunDestroyer[];
+        disposeFun<T extends import("./Destroyable").FunDestroyer>(fun: T): T;
+        cancelDisposeFun<T extends import("./Destroyable").FunDestroyer>(fun: T): T;
+        disposeObj<T extends /*elided*/ any>(obj: T, sync?: boolean): T;
+        cancelDisposeObj<T extends /*elided*/ any>(obj: T): T;
+        dispose<T extends import("./Destroyable").FunDestroyer>(fun: T): T;
+        dispose<T extends /*elided*/ any>(obj: T, asyncDestroy?: boolean): T;
+        dispose<T extends import("./Destroyable").FunDestroyer | /*elided*/ any>(objOrFun: T, asyncDestroy?: boolean): T;
+        cancelDispose<T extends import("./Destroyable").FunDestroyer>(fun: T): T;
+        cancelDispose<T extends /*elided*/ any>(obj: T): T;
+        cancelDispose<T extends import("./Destroyable").FunDestroyer | /*elided*/ any>(objOrFun: T): T;
+        destroyThis(): void;
+        destroy(): true | undefined;
+        destroyAsync(): Promise<true | undefined>;
+    };
+} & typeof EventEmitter;
+/**
+ * NodeDestroyable 类的类型
+ */
+export type NodeDestroyableClass = typeof NodeDestroyable;
+/**
+ * NodeDestroyable 实例的类型
+ */
+export type NodeDestroyable = InstanceType<NodeDestroyableClass>;
+//# sourceMappingURL=DestroyableSub.d.ts.map

package/dist/DestroyableSub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DestroyableSub.d.ts","sourceRoot":"","sources":["../src/DestroyableSub.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAEzC;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;mBAAsC,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,cAAc,CAAC;AAExD;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,YAAY,CAAC,mBAAmB,CAAC,CAAC;AAE/D;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;uBAA0C,CAAC;AAEvE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,eAAe,CAAC;AAE1D;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,YAAY,CAAC,oBAAoB,CAAC,CAAC"}

package/dist/createDestroyableSubClass.d.ts

@@ -0,0 +1,82 @@
+import type { FunDestroyer } from "./Destroyable";
+/**
+ * 创建可销毁的子类
+ * @remarks
+ * 用于根据传入的父类 动态生成可可销毁的子类
+ * @param ParentClass
+ * @returns
+ */
+export declare function createDestroyableSubClass<P extends new (...args: any) => any>(ParentClass: P): {
+    new (...args: any): {
+        [x: string]: any;
+        /**
+         * 是否已经销毁
+         */
+        readonly isDestroyed: boolean;
+        _isDestroyed: boolean;
+        /**
+         * 销毁者
+         */
+        _destroyers: FunDestroyer[];
+        /**
+         * 添加销毁者
+         * @param fun
+         * @returns 返回销毁者的顺序
+         */
+        disposeFun<T extends FunDestroyer>(fun: T): T;
+        /**
+         * 取消销毁者函数
+         * @param fun
+         * @returns
+         */
+        cancelDisposeFun<T extends FunDestroyer>(fun: T): T;
+        /**
+         * 添加销毁对象
+         * @param obj
+         * @param sync - 表示是否使用  `obj.destroy()` 方法进行销毁；默认使用   `obj.destroyAsync()` 方法进行销毁
+         * @returns
+         */
+        disposeObj<T extends /*elided*/ any>(obj: T, sync?: boolean): T;
+        /**
+         * 取消销毁者函数
+         * @param fun
+         * @returns
+         */
+        cancelDisposeObj<T extends /*elided*/ any>(obj: T): T;
+        /**
+         * 添加销毁函数或销毁对象
+         * @param fun
+         */
+        dispose<T extends FunDestroyer>(fun: T): T;
+        dispose<T extends /*elided*/ any>(obj: T, asyncDestroy?: boolean): T;
+        dispose<T extends /*elided*/ any | FunDestroyer>(objOrFun: T, asyncDestroy?: boolean): T;
+        cancelDispose<T extends FunDestroyer>(fun: T): T;
+        cancelDispose<T extends /*elided*/ any>(obj: T): T;
+        cancelDispose<T extends /*elided*/ any | FunDestroyer>(objOrFun: T): T;
+        /**
+         * 自己的销毁方法
+         * @remarks
+         * 子类根据需要进行重载
+         */
+        destroyThis(): void;
+        /**
+         * 销毁
+         */
+        destroy(): true | undefined;
+        /**
+         * 异步销毁
+         * @remarks
+         * 会依次执行销毁，并且只有上一个销毁完成之后才会执行下一个销毁
+         */
+        destroyAsync(): Promise<true | undefined>;
+    };
+} & P;
+/**
+ * createDestroyableSubClass 创建的类的类型
+ */
+export type DestroyableSubClass<ParentClass extends new (...args: any) => any> = ReturnType<typeof createDestroyableSubClass<ParentClass>>;
+/**
+ * createDestroyableSubClass 创建的类的实例类型
+ */
+export type DestroyableSub<ParentClass extends new (...args: any) => any> = InstanceType<DestroyableSubClass<ParentClass>>;
+//# sourceMappingURL=createDestroyableSubClass.d.ts.map

package/dist/createDestroyableSubClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDestroyableSubClass.d.ts","sourceRoot":"","sources":["../src/createDestroyableSubClass.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGlD;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,EAAE,WAAW,EAAE,CAAC;kBAA3B,GAAG;;QAM7D;;WAEG;;;QAMH;;WAEG;qBACU,YAAY,EAAE;QAE3B;;;;WAIG;mBACQ,CAAC,SAAS,YAAY,OAAO,CAAC,GAAG,CAAC;QAK7C;;;;WAIG;yBACc,CAAC,SAAS,YAAY,OAAO,CAAC,GAAG,CAAC;QAMnD;;;;;WAKG;mBACQ,CAAC,8BAA8B,CAAC,SAAS,OAAO,GAAG,CAAC;QAQ/D;;;;WAIG;yBACc,CAAC,8BAA8B,CAAC,GAAG,CAAC;QASrD;;;WAGG;gBACK,CAAC,SAAS,YAAY,OAAO,CAAC,GAAG,CAAC;gBAClC,CAAC,8BAA8B,CAAC,iBAAiB,OAAO,GAAG,CAAC;gBAC5D,CAAC,SAAS,iBAAiB,YAAY,YAAY,CAAC,iBAAiB,OAAO,GAAG,CAAC;sBAS1E,CAAC,SAAS,YAAY,OAAO,CAAC,GAAG,CAAC;sBAClC,CAAC,8BAA8B,CAAC,GAAG,CAAC;sBACpC,CAAC,SAAS,iBAAiB,YAAY,YAAY,CAAC,GAAG,CAAC;QActE;;;;WAIG;;QAMH;;WAEG;;QAkBH;;;;WAIG;;;MA+CV;AAMD;;GAEG;AACH,MAAM,MAAM,mBAAmB,CAAC,WAAW,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,IAAI,UAAU,CAAC,OAAO,yBAAyB,CAAC,WAAW,CAAC,CAAC,CAAC;AAE3I;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,WAAW,SAAS,KAAK,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,IAAI,YAAY,CAAC,mBAAmB,CAAC,WAAW,CAAC,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 可销毁的
+ *
+ * @remarks
+ * @gby/destroyable 提供了用于构建可销毁对象的类的基类，用于使得地管理可销毁对象的生命周期
+ *
+ * @packageDocumentation
+ */
+export * from './Destroyable';
+export * from "./createDestroyableSubClass";
+export * from "./DestroyableSub";
+//# 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;;;;;;;GAOG;AAEH,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAA;AAC3C,cAAc,kBAAkB,CAAA"}