@difizen/libro-common 0.3.3 → 1.0.0

package/es/core/toolbar/toolbar-protocol.js

@@ -0,0 +1,32 @@
+/**
+ * Instance of toolbar
+ * Use this token to get the toolbar instance when customizing elements on the toolbar.
+ */
+export var ToolbarInstance = Symbol('ToolbarInstance');
+
+/**
+ * Factory for instantiating toolbars.
+ */
+export var ToolbarItemFactory = Symbol('ToolbarItemFactory');
+export var ToolbarNode = Symbol('ToolbarItemDefinition');
+export var ToolbarItem;
+(function (_ToolbarItem) {
+  function isDefinition(arg) {
+    return !!arg && 'id' in arg && 'command' in arg && typeof arg.command === 'string';
+  }
+  _ToolbarItem.isDefinition = isDefinition;
+  function is(arg) {
+    return isDefinition(arg) && 'onDisposed' in arg;
+  }
+  _ToolbarItem.is = is;
+  function getGroupKey(record) {
+    if (!record.group) {
+      return '';
+    }
+    if (typeof record.group === 'string') {
+      return record.group;
+    }
+    return record.group.join('.');
+  }
+  _ToolbarItem.getGroupKey = getGroupKey;
+})(ToolbarItem || (ToolbarItem = {}));

package/es/core/toolbar/toolbar-registry.d.ts

@@ -0,0 +1,37 @@
+import { Emitter } from '../../common/index.js';
+import type { Contribution } from '../../ioc/index.js';
+import { Syringe } from '../../ioc/index.js';
+import { ApplicationContribution } from '../application';
+import type { ToolbarNode } from './toolbar-protocol';
+import { ToolbarItem, ToolbarItemFactory } from './toolbar-protocol';
+/**
+ * Clients should implement this interface if they want to contribute to the toolbar.
+ */
+export declare const ToolbarContribution: Syringe.DefinedToken;
+export type ToolbarContribution = {
+    /**
+     * Registers toolbar items.
+     * @param registry the toolbar registry.
+     */
+    registerToolbarItems: (registry: ToolbarRegistry) => void;
+};
+/**
+ * Main, shared registry for tab-bar toolbar items.
+ */
+export declare class ToolbarRegistry implements ApplicationContribution {
+    items: Map<string, ToolbarItem>;
+    protected readonly toolbarItemFactory: ToolbarItemFactory;
+    protected readonly contributionProvider: Contribution.Provider<ToolbarContribution>;
+    constructor(toolbarItemFactory: ToolbarItemFactory, contributionProvider: Contribution.Provider<ToolbarContribution>);
+    protected readonly onDidChangeEmitter: Emitter<void>;
+    onStart(): void;
+    /**
+     * Registers the given item. Throws an error, if the corresponding command cannot be found or an item has been already registered for the desired command.
+     *
+     * @param item the item to register.
+     */
+    registerItem(def: ToolbarNode): ToolbarItem;
+    getToolbarItem(id: string): ToolbarItem | undefined;
+    unregisterItem(itemOrId: ToolbarNode | string): void;
+}
+//# sourceMappingURL=toolbar-registry.d.ts.map

package/es/core/toolbar/toolbar-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolbar-registry.d.ts","sourceRoot":"","sources":["../../../src/core/toolbar/toolbar-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAA8B,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAEzE,OAAO,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAEzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AACrE;;GAEG;AACH,eAAO,MAAM,mBAAmB,sBAA6C,CAAC;AAE9E,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;OAGG;IACH,oBAAoB,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,IAAI,CAAC;CAC3D,CAAC;AAEF;;GAEG;AACH,qBACa,eAAgB,YAAW,uBAAuB;IAE7D,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAa;IAE5C,SAAS,CAAC,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;IAC1D,SAAS,CAAC,QAAQ,CAAC,oBAAoB,EAAE,YAAY,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;gBAIlF,kBAAkB,EAAE,kBAAkB,EAEtC,oBAAoB,EAAE,YAAY,CAAC,QAAQ,CAAC,mBAAmB,CAAC;IAMlE,SAAS,CAAC,QAAQ,CAAC,kBAAkB,gBAAuB;IAE5D,OAAO,IAAI,IAAI;IAOf;;;;OAIG;IACH,YAAY,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW;IAW3C,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAInD,cAAc,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI;CAIrD"}

package/es/core/toolbar/toolbar-registry.js

@@ -0,0 +1,96 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _dec, _dec2, _class, _class2, _descriptor;
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'transform-class-properties is enabled and runs after the decorators transform.'); }
+import { Emitter } from "../../common/index.js";
+import { prop } from "../../observable/index.js";
+import { contrib, inject, singleton, Syringe } from "../../ioc/index.js";
+import { ApplicationContribution } from "../application";
+import { ToolbarItem, ToolbarItemFactory } from "./toolbar-protocol";
+/**
+ * Clients should implement this interface if they want to contribute to the toolbar.
+ */
+export var ToolbarContribution = Syringe.defineToken('ToolbarContribution');
+/**
+ * Main, shared registry for tab-bar toolbar items.
+ */
+export var ToolbarRegistry = (_dec = singleton({
+  contrib: ApplicationContribution
+}), _dec2 = prop(), _dec(_class = (_class2 = /*#__PURE__*/function () {
+  function ToolbarRegistry(toolbarItemFactory, contributionProvider) {
+    _classCallCheck(this, ToolbarRegistry);
+    _initializerDefineProperty(this, "items", _descriptor, this);
+    this.onDidChangeEmitter = new Emitter();
+    this.toolbarItemFactory = toolbarItemFactory;
+    this.contributionProvider = contributionProvider;
+  }
+  ToolbarRegistry = contrib(ToolbarContribution)(ToolbarRegistry, undefined, 1) || ToolbarRegistry;
+  ToolbarRegistry = inject(ToolbarItemFactory)(ToolbarRegistry, undefined, 0) || ToolbarRegistry;
+  _createClass(ToolbarRegistry, [{
+    key: "onStart",
+    value: function onStart() {
+      var contributions = this.contributionProvider.getContributions();
+      var _iterator = _createForOfIteratorHelper(contributions),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var contribution = _step.value;
+          contribution.registerToolbarItems(this);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+
+    /**
+     * Registers the given item. Throws an error, if the corresponding command cannot be found or an item has been already registered for the desired command.
+     *
+     * @param item the item to register.
+     */
+  }, {
+    key: "registerItem",
+    value: function registerItem(def) {
+      var _this = this;
+      var id = def.id;
+      if (this.items.has(id)) {
+        throw new Error("A toolbar item is already registered with the '".concat(id, "' ID."));
+      }
+      var item = ToolbarItem.is(def) ? def : this.toolbarItemFactory(def);
+      this.items.set(id, item);
+      item.onDisposed(function () {
+        return _this.items.delete(id);
+      });
+      return item;
+    }
+  }, {
+    key: "getToolbarItem",
+    value: function getToolbarItem(id) {
+      return this.items.get(id);
+    }
+  }, {
+    key: "unregisterItem",
+    value: function unregisterItem(itemOrId) {
+      var id = typeof itemOrId === 'string' ? itemOrId : itemOrId.id;
+      this.items.delete(id);
+    }
+  }]);
+  return ToolbarRegistry;
+}(), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "items", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: function initializer() {
+    return new Map();
+  }
+})), _class2)) || _class);

package/es/core/typings/native-keymap.d.ts

@@ -0,0 +1,72 @@
+declare module 'native-keymap' {
+  /*---------------------------------------------------------------------------------------------
+   *  Copyright (c) Microsoft Corporation. All rights reserved.
+   *  Licensed under the MIT License. See License.txt in the project root for license information.
+   *--------------------------------------------------------------------------------------------*/
+
+  export interface IWindowsKeyMapping {
+    vkey: string;
+    value: string;
+    withShift: string;
+    withAltGr: string;
+    withShiftAltGr: string;
+  }
+  export type IWindowsKeyboardMapping = Record<string, IWindowsKeyMapping>;
+  export interface ILinuxKeyMapping {
+    value: string;
+    withShift: string;
+    withAltGr: string;
+    withShiftAltGr: string;
+  }
+  export type ILinuxKeyboardMapping = Record<string, ILinuxKeyMapping>;
+  export interface IMacKeyMapping {
+    value: string;
+    valueIsDeadKey: boolean;
+    withShift: string;
+    withShiftIsDeadKey: boolean;
+    withAltGr: string;
+    withAltGrIsDeadKey: boolean;
+    withShiftAltGr: string;
+    withShiftAltGrIsDeadKey: boolean;
+  }
+  export type IMacKeyboardMapping = Record<string, IMacKeyMapping>;
+
+  export type IKeyboardMapping =
+    | IWindowsKeyboardMapping
+    | ILinuxKeyboardMapping
+    | IMacKeyboardMapping;
+
+  export function getKeyMap(): IKeyboardMapping;
+
+  export interface IWindowsKeyboardLayoutInfo {
+    name: string;
+    id: string;
+    text: string;
+  }
+
+  export interface ILinuxKeyboardLayoutInfo {
+    model: string;
+    group: number;
+    layout: string;
+    variant: string;
+    options: string;
+    rules: string;
+  }
+
+  export interface IMacKeyboardLayoutInfo {
+    id: string;
+    localizedName: string;
+    lang: string;
+  }
+
+  export type IKeyboardLayoutInfo =
+    | IWindowsKeyboardLayoutInfo
+    | ILinuxKeyboardLayoutInfo
+    | IMacKeyboardLayoutInfo;
+
+  export function getCurrentKeyboardLayout(): IKeyboardLayoutInfo;
+
+  export function onDidChangeKeyboardLayout(callback: () => void): void;
+
+  export function isISOKeyboard(): boolean | undefined;
+}

package/es/core/utils/hooks.d.ts

@@ -0,0 +1,12 @@
+import type { RefObject } from 'react';
+export declare function useLatest<T>(value: T): import("react").MutableRefObject<T>;
+export declare const useUnmount: (fn: () => void) => void;
+export declare const useMount: (fn: () => void) => void;
+type Size = {
+    width: number;
+    height: number;
+};
+export declare function useSize(ref: RefObject<HTMLDivElement>): Size | undefined;
+export declare function useSizeCallback(fn: (size: Size) => void, ref: React.ForwardedRef<HTMLDivElement>): void;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/es/core/utils/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/core/utils/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,uCAKpC;AAED,eAAO,MAAM,UAAU,OAAQ,MAAM,IAAI,SAUxC,CAAC;AAEF,eAAO,MAAM,QAAQ,OAAQ,MAAM,IAAI,SAKtC,CAAC;AAqBF,KAAK,IAAI,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9C,wBAAgB,OAAO,CAAC,GAAG,EAAE,SAAS,CAAC,cAAc,CAAC,GAAG,IAAI,GAAG,SAAS,CA0BxE;AAED,wBAAgB,eAAe,CAC7B,EAAE,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,EACxB,GAAG,EAAE,KAAK,CAAC,YAAY,CAAC,cAAc,CAAC,GACtC,IAAI,CA0BN"}

package/es/core/utils/hooks.js

@@ -0,0 +1,103 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useRef, useEffect, useLayoutEffect, useState, useCallback } from 'react';
+export function useLatest(value) {
+  var ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+export var useUnmount = function useUnmount(fn) {
+  var fnRef = useLatest(fn);
+  useEffect(function () {
+    return function () {
+      fnRef.current();
+    };
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  []);
+};
+export var useMount = function useMount(fn) {
+  useEffect(function () {
+    fn === null || fn === void 0 || fn();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+};
+function useRafState(initialState) {
+  var ref = useRef(0);
+  var _useState = useState(initialState),
+    _useState2 = _slicedToArray(_useState, 2),
+    state = _useState2[0],
+    setState = _useState2[1];
+  var setRafState = useCallback(function (value) {
+    cancelAnimationFrame(ref.current);
+    ref.current = requestAnimationFrame(function () {
+      setState(value);
+    });
+  }, []);
+  useUnmount(function () {
+    cancelAnimationFrame(ref.current);
+  });
+  return [state, setRafState];
+}
+export function useSize(ref) {
+  var _useRafState = useRafState(),
+    _useRafState2 = _slicedToArray(_useRafState, 2),
+    size = _useRafState2[0],
+    setSize = _useRafState2[1];
+  useLayoutEffect(function () {
+    if (_typeof(ref) !== 'object') {
+      return;
+    }
+    var el = ref === null || ref === void 0 ? void 0 : ref.current;
+    if (!el) {
+      return;
+    }
+    var resizeObserver = new ResizeObserver(function (entries) {
+      entries.forEach(function (entry) {
+        var _entry$target = entry.target,
+          clientWidth = _entry$target.clientWidth,
+          clientHeight = _entry$target.clientHeight;
+        setSize({
+          width: clientWidth,
+          height: clientHeight
+        });
+      });
+    });
+    resizeObserver.observe(el);
+    return function () {
+      resizeObserver.disconnect();
+    };
+  }, [ref, setSize]);
+  return size;
+}
+export function useSizeCallback(fn, ref) {
+  var callback = useLatest(function (size) {
+    fn(size);
+  });
+  useLayoutEffect(function () {
+    if (_typeof(ref) !== 'object') {
+      return;
+    }
+    var el = ref === null || ref === void 0 ? void 0 : ref.current;
+    if (!el || !fn) {
+      return;
+    }
+    var resizeObserver = new ResizeObserver(function (entries) {
+      entries.forEach(function (entry) {
+        callback.current({
+          width: entry.target.clientWidth,
+          height: entry.target.clientHeight
+        });
+      });
+    });
+    resizeObserver.observe(el);
+    return function () {
+      resizeObserver.disconnect();
+    };
+  }, [callback, ref, fn]);
+}

package/es/core/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lifecycle';
+export * from './map';
+export * from './hooks';
+//# sourceMappingURL=index.d.ts.map

package/es/core/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC"}

package/es/core/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./lifecycle";
+export * from "./map";
+export * from "./hooks";

package/es/core/utils/lifecycle.d.ts

@@ -0,0 +1,75 @@
+export declare function once<T extends (...args: any[]) => any>(this: unknown, fn: T): T;
+export interface IDisposableTracker {
+    trackDisposable: (x: IDisposable) => void;
+    markTracked: (x: IDisposable) => void;
+}
+export declare function setDisposableTracker(tracker: IDisposableTracker | null): void;
+export declare function trackDisposable<T extends IDisposable>(x: T): T;
+export declare class MultiDisposeError extends Error {
+    readonly errors: any[];
+    constructor(errors: any[]);
+}
+export interface IDisposable {
+    dispose: () => void;
+}
+export declare function isDisposable<E extends object>(thing: E): thing is E & IDisposable;
+export declare function dispose<T extends IDisposable>(disposable: T): T;
+export declare function dispose<T extends IDisposable>(disposable: T | undefined): T | undefined;
+export declare function dispose<T extends IDisposable, A extends IterableIterator<T> = IterableIterator<T>>(disposables: IterableIterator<T>): A;
+export declare function dispose<T extends IDisposable>(disposables: T[]): T[];
+export declare function dispose<T extends IDisposable>(disposables: readonly T[]): readonly T[];
+export declare function combinedDisposable(...disposables: IDisposable[]): IDisposable;
+export declare function toDisposable(fn: () => void): IDisposable;
+export declare class DisposableStore implements IDisposable {
+    static DISABLE_DISPOSED_WARNING: boolean;
+    private _toDispose;
+    private _isDisposed;
+    /**
+     * Dispose of all registered disposables and mark this object as disposed.
+     *
+     * Any future disposables added to this object will be disposed of on `add`.
+     */
+    dispose(): void;
+    /**
+     * Dispose of all registered disposables but do not mark this object as disposed.
+     */
+    clear(): void;
+    add<T extends IDisposable>(t: T): T;
+}
+export declare abstract class VSDisposable implements IDisposable {
+    static readonly None: Readonly<IDisposable>;
+    private readonly _store;
+    constructor();
+    dispose(): void;
+    protected _register<T extends IDisposable>(t: T): T;
+}
+/**
+ * Manages the lifecycle of a disposable value that may be changed.
+ *
+ * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can
+ * also register a `MutableDisposable` on a `VSDisposable` to ensure it is automatically cleaned up.
+ */
+export declare class MutableDisposable<T extends IDisposable> implements IDisposable {
+    private _value?;
+    private _isDisposed;
+    constructor();
+    get value(): T | undefined;
+    set value(value: T | undefined);
+    clear(): void;
+    dispose(): void;
+}
+export interface IReference<T> extends IDisposable {
+    readonly object: T;
+}
+export declare abstract class ReferenceCollection<T> {
+    private readonly references;
+    acquire(key: string, ...args: any[]): IReference<T>;
+    protected abstract createReferencedObject(key: string, ...args: any[]): T;
+    protected abstract destroyReferencedObject(key: string, object: T): void;
+}
+export declare class ImmortalReference<T> implements IReference<T> {
+    object: T;
+    constructor(object: T);
+    dispose(): void;
+}
+//# sourceMappingURL=lifecycle.d.ts.map

package/es/core/utils/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../src/core/utils/lifecycle.ts"],"names":[],"mappings":"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"}