@difizen/libro-common 0.3.4 → 1.0.0

package/es/core/view/focus-tracker.d.ts

@@ -0,0 +1,165 @@
+import type { Disposable, Event as EmitterEvent } from '../../common/index.js';
+import { Emitter } from '../../common/index.js';
+import type { View } from './view-protocol';
+/**
+ * A class which tracks focus among a set of views.
+ *
+ * This class is useful when code needs to keep track of the most
+ * recently focused view(s) among a set of related views.
+ */
+export declare class FocusTracker<T extends View> implements Disposable {
+    protected counter: number;
+    protected _views: T[];
+    protected _activeView: T | null;
+    protected _currentView: T | null;
+    protected numbers: Map<T, number>;
+    protected nodes: Map<HTMLElement, T>;
+    protected activeChangedEmitter: Emitter<FocusTracker.IChangedArgs<T>>;
+    protected currentChangedEmitter: Emitter<FocusTracker.IChangedArgs<T>>;
+    /**
+     * A signal emitted when the current view has changed.
+     */
+    get currentChanged(): EmitterEvent<FocusTracker.IChangedArgs<T>>;
+    /**
+     * A signal emitted when the active view has changed.
+     */
+    get activeChanged(): EmitterEvent<FocusTracker.IChangedArgs<T>>;
+    /**
+     * A flag indicating whether the tracker is disposed.
+     */
+    get isDisposed(): boolean;
+    /**
+     * The current view in the tracker.
+     *
+     * #### Notes
+     * The current view is the view among the tracked views which
+     * has the *descendant node* which has most recently been focused.
+     *
+     * The current view will not be updated if the node loses focus. It
+     * will only be updated when a different tracked view gains focus.
+     *
+     * If the current view is removed from the tracker, the previous
+     * current view will be restored.
+     *
+     * This behavior is intended to follow a user's conceptual model of
+     * a semantically "current" view, where the "last thing of type X"
+     * to be interacted with is the "current instance of X", regardless
+     * of whether that instance still has focus.
+     */
+    get currentView(): T | null;
+    /**
+     * The active view in the tracker.
+     *
+     * #### Notes
+     * The active view is the view among the tracked views which
+     * has the *descendant node* which is currently focused.
+     */
+    get activeView(): T | null;
+    /**
+     * A read only array of the views being tracked.
+     */
+    get views(): readonly T[];
+    /**
+     * Dispose of the resources held by the tracker.
+     */
+    dispose(): void;
+    /**
+     * Get the focus number for a particular view in the tracker.
+     *
+     * @param view - The view of interest.
+     *
+     * @returns The focus number for the given view, or `-1` if the
+     *   view has not had focus since being added to the tracker, or
+     *   is not contained by the tracker.
+     *
+     * #### Notes
+     * The focus number indicates the relative order in which the views
+     * have gained focus. A view with a larger number has gained focus
+     * more recently than a view with a smaller number.
+     *
+     * The `currentView` will always have the largest focus number.
+     *
+     * All views start with a focus number of `-1`, which indicates that
+     * the view has not been focused since being added to the tracker.
+     */
+    focusNumber(view: T): number;
+    /**
+     * Test whether the focus tracker contains a given view.
+     *
+     * @param view - The view of interest.
+     *
+     * @returns `true` if the view is tracked, `false` otherwise.
+     */
+    has(view: T): boolean;
+    /**
+     * Add a view to the focus tracker.
+     *
+     * @param view - The view of interest.
+     *
+     * #### Notes
+     * A view will be automatically removed from the tracker if it
+     * is disposed after being added.
+     *
+     * If the view is already tracked, this is a no-op.
+     */
+    add(view: T): void;
+    /**
+     * Remove a view from the focus tracker.
+     *
+     * #### Notes
+     * If the view is the `currentView`, the previous current view
+     * will become the new `currentView`.
+     *
+     * A view will be automatically removed from the tracker if it
+     * is disposed after being added.
+     *
+     * If the view is not tracked, this is a no-op.
+     */
+    remove(view: T): void;
+    /**
+     * Handle the DOM events for the focus tracker.
+     *
+     * @param event - The DOM event sent to the panel.
+     *
+     * #### Notes
+     * This method implements the DOM `EventListener` interface and is
+     * called in response to events on the tracked nodes. It should
+     * not be called directly by user code.
+     */
+    handleEvent(event: Event): void;
+    /**
+     * Set the current and active views for the tracker.
+     */
+    protected setViews(current: T | null, active: T | null): void;
+    /**
+     * Handle the `'focus'` event for a tracked view.
+     */
+    protected handleFocusEvent(event: FocusEvent): void;
+    /**
+     * Handle the `'blur'` event for a tracked view.
+     */
+    protected handleBlurEvent(event: FocusEvent): void;
+    /**
+     * Handle the `disposed` signal for a tracked view.
+     */
+    protected onViewDisposed(sender: T): void;
+}
+/**
+ * The namespace for the `FocusTracker` class statics.
+ */
+export declare namespace FocusTracker {
+    /**
+     * An arguments object for the changed signals.
+     */
+    interface IChangedArgs<T extends View> {
+        /**
+         * The old value for the view.
+         */
+        oldValue: T | null;
+        /**
+         * The new value for the view.
+         */
+        newValue: T | null;
+    }
+}
+//# sourceMappingURL=focus-tracker.d.ts.map

package/es/core/view/focus-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-tracker.d.ts","sourceRoot":"","sources":["../../../src/core/view/focus-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,IAAI,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE/E,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAGhD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;GAKG;AACH,qBACa,YAAY,CAAC,CAAC,SAAS,IAAI,CAAE,YAAW,UAAU;IAC7D,SAAS,CAAC,OAAO,SAAK;IACtB,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,CAAM;IAC3B,SAAS,CAAC,WAAW,EAAE,CAAC,GAAG,IAAI,CAAQ;IACvC,SAAS,CAAC,YAAY,EAAE,CAAC,GAAG,IAAI,CAAQ;IACxC,SAAS,CAAC,OAAO,iBAAwB;IACzC,SAAS,CAAC,KAAK,sBAA6B;IAC5C,SAAS,CAAC,oBAAoB,wCAA+C;IAC7E,SAAS,CAAC,qBAAqB,wCAA+C;IAE9E;;OAEG;IACH,IAAI,cAAc,IAAI,YAAY,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAE/D;IAED;;OAEG;IACH,IAAI,aAAa,IAAI,YAAY,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAE9D;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,OAAO,CAExB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,WAAW,IAAI,CAAC,GAAG,IAAI,CAE1B;IAED;;;;;;OAMG;IACH,IAAI,UAAU,IAAI,CAAC,GAAG,IAAI,CAEzB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,SAAS,CAAC,EAAE,CAExB;IAED;;OAEG;IACH,OAAO,IAAI,IAAI;IA2Bf;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAAW,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM;IAK5B;;;;;;OAMG;IACH,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO;IAIrB;;;;;;;;;;OAUG;IACH,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAkClB;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAyCrB;;;;;;;;;OASG;IACH,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAW/B;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI;IAoB7D;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAanD;;OAEG;IACH,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI;IAyBlD;;OAEG;IACH,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI;CAG1C;AAED;;GAEG;AACH,yBAAiB,YAAY,CAAC;IAC5B;;OAEG;IACH,UAAiB,YAAY,CAAC,CAAC,SAAS,IAAI;QAC1C;;WAEG;QACH,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC;QAEnB;;WAEG;QACH,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC;KACpB;CACF"}

package/es/core/view/focus-tracker.js

@@ -0,0 +1,411 @@
+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, _class;
+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); }
+import { Iterable } from "../../common/index.js";
+import { Emitter } from "../../common/index.js";
+import { singleton } from "../../ioc/index.js";
+/**
+ * A class which tracks focus among a set of views.
+ *
+ * This class is useful when code needs to keep track of the most
+ * recently focused view(s) among a set of related views.
+ */
+export var FocusTracker = (_dec = singleton(), _dec(_class = /*#__PURE__*/function () {
+  function FocusTracker() {
+    _classCallCheck(this, FocusTracker);
+    this.counter = 0;
+    this._views = [];
+    this._activeView = null;
+    this._currentView = null;
+    this.numbers = new Map();
+    this.nodes = new Map();
+    this.activeChangedEmitter = new Emitter();
+    this.currentChangedEmitter = new Emitter();
+  }
+  _createClass(FocusTracker, [{
+    key: "currentChanged",
+    get:
+    /**
+     * A signal emitted when the current view has changed.
+     */
+    function get() {
+      return this.currentChangedEmitter.event;
+    }
+
+    /**
+     * A signal emitted when the active view has changed.
+     */
+  }, {
+    key: "activeChanged",
+    get: function get() {
+      return this.activeChangedEmitter.event;
+    }
+
+    /**
+     * A flag indicating whether the tracker is disposed.
+     */
+  }, {
+    key: "isDisposed",
+    get: function get() {
+      return this.counter < 0;
+    }
+
+    /**
+     * The current view in the tracker.
+     *
+     * #### Notes
+     * The current view is the view among the tracked views which
+     * has the *descendant node* which has most recently been focused.
+     *
+     * The current view will not be updated if the node loses focus. It
+     * will only be updated when a different tracked view gains focus.
+     *
+     * If the current view is removed from the tracker, the previous
+     * current view will be restored.
+     *
+     * This behavior is intended to follow a user's conceptual model of
+     * a semantically "current" view, where the "last thing of type X"
+     * to be interacted with is the "current instance of X", regardless
+     * of whether that instance still has focus.
+     */
+  }, {
+    key: "currentView",
+    get: function get() {
+      return this._currentView;
+    }
+
+    /**
+     * The active view in the tracker.
+     *
+     * #### Notes
+     * The active view is the view among the tracked views which
+     * has the *descendant node* which is currently focused.
+     */
+  }, {
+    key: "activeView",
+    get: function get() {
+      return this._activeView;
+    }
+
+    /**
+     * A read only array of the views being tracked.
+     */
+  }, {
+    key: "views",
+    get: function get() {
+      return this._views;
+    }
+
+    /**
+     * Dispose of the resources held by the tracker.
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      var _this = this;
+      // Do nothing if the tracker is already disposed.
+      if (this.counter < 0) {
+        return;
+      }
+
+      // Mark the tracker as disposed.
+      this.counter = -1;
+
+      // Clear the listeners for the tracker.
+      this.activeChangedEmitter.dispose();
+      this.currentChangedEmitter.dispose();
+
+      // Remove all event listeners.
+      this._views.forEach(function (view) {
+        var _view$container, _view$container2;
+        (_view$container = view.container) === null || _view$container === void 0 || (_view$container = _view$container.current) === null || _view$container === void 0 || _view$container.removeEventListener('focus', _this, true);
+        (_view$container2 = view.container) === null || _view$container2 === void 0 || (_view$container2 = _view$container2.current) === null || _view$container2 === void 0 || _view$container2.removeEventListener('blur', _this, true);
+      });
+
+      // Clear the internal data structures.
+      this._activeView = null;
+      this._currentView = null;
+      this.nodes.clear();
+      this.numbers.clear();
+      this._views.length = 0;
+    }
+
+    /**
+     * Get the focus number for a particular view in the tracker.
+     *
+     * @param view - The view of interest.
+     *
+     * @returns The focus number for the given view, or `-1` if the
+     *   view has not had focus since being added to the tracker, or
+     *   is not contained by the tracker.
+     *
+     * #### Notes
+     * The focus number indicates the relative order in which the views
+     * have gained focus. A view with a larger number has gained focus
+     * more recently than a view with a smaller number.
+     *
+     * The `currentView` will always have the largest focus number.
+     *
+     * All views start with a focus number of `-1`, which indicates that
+     * the view has not been focused since being added to the tracker.
+     */
+  }, {
+    key: "focusNumber",
+    value: function focusNumber(view) {
+      var n = this.numbers.get(view);
+      return n === undefined ? -1 : n;
+    }
+
+    /**
+     * Test whether the focus tracker contains a given view.
+     *
+     * @param view - The view of interest.
+     *
+     * @returns `true` if the view is tracked, `false` otherwise.
+     */
+  }, {
+    key: "has",
+    value: function has(view) {
+      return this.numbers.has(view);
+    }
+
+    /**
+     * Add a view to the focus tracker.
+     *
+     * @param view - The view of interest.
+     *
+     * #### Notes
+     * A view will be automatically removed from the tracker if it
+     * is disposed after being added.
+     *
+     * If the view is already tracked, this is a no-op.
+     */
+  }, {
+    key: "add",
+    value: function add(view) {
+      var _view$container3,
+        _view$container4,
+        _view$container6,
+        _view$container7,
+        _this2 = this;
+      // Do nothing if the view is already tracked.
+      if (this.numbers.has(view)) {
+        return;
+      }
+
+      // Test whether the view has focus.
+      var focused = (_view$container3 = view.container) === null || _view$container3 === void 0 || (_view$container3 = _view$container3.current) === null || _view$container3 === void 0 ? void 0 : _view$container3.contains(document.activeElement);
+
+      // Set up the initial focus number.
+      var n = focused ? this.counter++ : -1;
+
+      // Add the view to the internal data structures.
+      this._views.push(view);
+      this.numbers.set(view, n);
+      if ((_view$container4 = view.container) !== null && _view$container4 !== void 0 && _view$container4.current) {
+        var _view$container5;
+        this.nodes.set((_view$container5 = view.container) === null || _view$container5 === void 0 ? void 0 : _view$container5.current, view);
+      }
+
+      // Set up the event listeners. The capturing phase must be used
+      // since the 'focus' and 'blur' events don't bubble and Firefox
+      // doesn't support the 'focusin' or 'focusout' events.
+      (_view$container6 = view.container) === null || _view$container6 === void 0 || (_view$container6 = _view$container6.current) === null || _view$container6 === void 0 || _view$container6.addEventListener('focus', this, true);
+      (_view$container7 = view.container) === null || _view$container7 === void 0 || (_view$container7 = _view$container7.current) === null || _view$container7 === void 0 || _view$container7.addEventListener('blur', this, true);
+
+      // Connect the disposed signal handler.
+      view.onDisposed(function () {
+        return _this2.onViewDisposed;
+      });
+
+      // Set the current and active views if needed.
+      if (focused) {
+        this.setViews(view, view);
+      }
+    }
+
+    /**
+     * Remove a view from the focus tracker.
+     *
+     * #### Notes
+     * If the view is the `currentView`, the previous current view
+     * will become the new `currentView`.
+     *
+     * A view will be automatically removed from the tracker if it
+     * is disposed after being added.
+     *
+     * If the view is not tracked, this is a no-op.
+     */
+  }, {
+    key: "remove",
+    value: function remove(view) {
+      var _view$container8,
+        _view$container9,
+        _view$container10,
+        _this3 = this;
+      // Bail early if the view is not tracked.
+      if (!this.numbers.has(view)) {
+        return;
+      }
+
+      // Disconnect the disposed signal handler.
+      // view.disposed.disconnect(this.onViewDisposed, this);
+
+      // Remove the event listeners.
+      (_view$container8 = view.container) === null || _view$container8 === void 0 || (_view$container8 = _view$container8.current) === null || _view$container8 === void 0 || _view$container8.removeEventListener('focus', this, true);
+      (_view$container9 = view.container) === null || _view$container9 === void 0 || (_view$container9 = _view$container9.current) === null || _view$container9 === void 0 || _view$container9.removeEventListener('blur', this, true);
+
+      // Remove the view from the internal data structures.
+      this._views.splice(this._views.indexOf(view), 1);
+      if ((_view$container10 = view.container) !== null && _view$container10 !== void 0 && _view$container10.current) {
+        var _view$container11;
+        this.nodes.delete((_view$container11 = view.container) === null || _view$container11 === void 0 ? void 0 : _view$container11.current);
+      }
+      this.numbers.delete(view);
+
+      // Bail early if the view is not the current view.
+      if (this._currentView !== view) {
+        return;
+      }
+
+      // Filter the views for those which have had focus.
+      var valid = this._views.filter(function (w) {
+        return _this3.numbers.get(w) !== -1;
+      });
+
+      // Get the valid view with the max focus number.
+      var previous = Iterable.max(valid, function (first, second) {
+        var a = _this3.numbers.get(first);
+        var b = _this3.numbers.get(second);
+        return a - b;
+      }) || null;
+
+      // Set the current and active views.
+      this.setViews(previous, null);
+    }
+
+    /**
+     * Handle the DOM events for the focus tracker.
+     *
+     * @param event - The DOM event sent to the panel.
+     *
+     * #### Notes
+     * This method implements the DOM `EventListener` interface and is
+     * called in response to events on the tracked nodes. It should
+     * not be called directly by user code.
+     */
+  }, {
+    key: "handleEvent",
+    value: function handleEvent(event) {
+      switch (event.type) {
+        case 'focus':
+          this.handleFocusEvent(event);
+          break;
+        case 'blur':
+          this.handleBlurEvent(event);
+          break;
+      }
+    }
+
+    /**
+     * Set the current and active views for the tracker.
+     */
+  }, {
+    key: "setViews",
+    value: function setViews(current, active) {
+      // Swap the current view.
+      var oldCurrent = this._currentView;
+      this._currentView = current;
+
+      // Swap the active view.
+      var oldActive = this._activeView;
+      this._activeView = active;
+
+      // Emit the `currentChanged` signal if needed.
+      if (oldCurrent !== current) {
+        this.currentChangedEmitter.fire({
+          oldValue: oldCurrent,
+          newValue: current
+        });
+      }
+
+      // Emit the `activeChanged` signal if needed.
+      if (oldActive !== active) {
+        this.activeChangedEmitter.fire({
+          oldValue: oldActive,
+          newValue: active
+        });
+      }
+    }
+
+    /**
+     * Handle the `'focus'` event for a tracked view.
+     */
+  }, {
+    key: "handleFocusEvent",
+    value: function handleFocusEvent(event) {
+      // Find the view which gained focus, which is known to exist.
+      var view = this.nodes.get(event.currentTarget);
+
+      // Update the focus number if necessary.
+      if (view !== this._currentView) {
+        this.numbers.set(view, this.counter++);
+      }
+
+      // Set the current and active views.
+      this.setViews(view, view);
+    }
+
+    /**
+     * Handle the `'blur'` event for a tracked view.
+     */
+  }, {
+    key: "handleBlurEvent",
+    value: function handleBlurEvent(event) {
+      var _view$container12;
+      // Find the view which lost focus, which is known to exist.
+      var view = this.nodes.get(event.currentTarget);
+
+      // Get the node which being focused after this blur.
+      var focusTarget = event.relatedTarget;
+
+      // If no other node is being focused, clear the active view.
+      if (!focusTarget) {
+        this.setViews(this._currentView, null);
+        return;
+      }
+
+      // Bail if the focus view is not changing.
+      if ((_view$container12 = view.container) !== null && _view$container12 !== void 0 && (_view$container12 = _view$container12.current) !== null && _view$container12 !== void 0 && _view$container12.contains(focusTarget)) {
+        return;
+      }
+
+      // If no tracked view is being focused, clear the active view.
+      if (!this._views.find(function (v) {
+        var _v$container;
+        return (_v$container = v.container) === null || _v$container === void 0 || (_v$container = _v$container.current) === null || _v$container === void 0 ? void 0 : _v$container.contains(focusTarget);
+      })) {
+        this.setViews(this._currentView, null);
+        return;
+      }
+    }
+
+    /**
+     * Handle the `disposed` signal for a tracked view.
+     */
+  }, {
+    key: "onViewDisposed",
+    value: function onViewDisposed(sender) {
+      this.remove(sender);
+    }
+  }]);
+  return FocusTracker;
+}()) || _class);
+
+/**
+ * The namespace for the `FocusTracker` class statics.
+ */

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

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import type { View } from './view-protocol';
+export type Size = {
+    width?: number;
+    height?: number;
+};
+export declare function useViewSize(view: View, ref: React.ForwardedRef<HTMLDivElement>): void;
+//# sourceMappingURL=hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/core/view/hooks.tsx"],"names":[],"mappings":";AAKA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C,MAAM,MAAM,IAAI,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvD,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,YAAY,CAAC,cAAc,CAAC,GAAG,IAAI,CA8BrF"}

package/es/core/view/hooks.js

@@ -0,0 +1,35 @@
+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); }
+import { useLayoutEffect } from 'react';
+import ResizeObserver from 'resize-observer-polyfill';
+import { useLatest } from "../utils/index";
+export function useViewSize(view, ref) {
+  var callback = useLatest(function (size) {
+    var _view$onViewResize;
+    (_view$onViewResize = view.onViewResize) === null || _view$onViewResize === void 0 || _view$onViewResize.call(view, size);
+  });
+  useLayoutEffect(function () {
+    if (_typeof(ref) !== 'object') {
+      return function () {
+        //
+      };
+    }
+    var el = ref === null || ref === void 0 ? void 0 : ref.current;
+    if (!el || !view.onViewResize) {
+      return function () {
+        //
+      };
+    }
+    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, view.container, view.onViewResize]);
+}

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

@@ -0,0 +1,23 @@
+export * from './module';
+export * from './view-protocol';
+export * from './view-manager';
+export * from './slot-view-manager';
+export * from './default-slot-view';
+export * from './default-view';
+export * from './slot';
+export * from './decorator';
+export * from './view-decoration';
+export * from './open-handler';
+export * from './view-open-handler';
+export * from './navigatable';
+export * from './navigatable-types';
+export * from './saveable';
+export * from './view-application';
+export * from './view-context';
+export * from './view-render';
+export * from './view-decoration';
+export * from './view-storage';
+export * from './stateful-view';
+export * from './utils';
+export * from './hooks';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/view/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}

package/es/core/view/index.js

@@ -0,0 +1,22 @@
+export * from "./module";
+export * from "./view-protocol";
+export * from "./view-manager";
+export * from "./slot-view-manager";
+export * from "./default-slot-view";
+export * from "./default-view";
+export * from "./slot";
+export * from "./decorator";
+export * from "./view-decoration";
+export * from "./open-handler";
+export * from "./view-open-handler";
+export * from "./navigatable";
+export * from "./navigatable-types";
+export * from "./saveable";
+export * from "./view-application";
+export * from "./view-context";
+export * from "./view-render";
+export * from "./view-decoration";
+export * from "./view-storage";
+export * from "./stateful-view";
+export * from "./utils";
+export * from "./hooks";

package/es/core/view/index.less

@@ -0,0 +1,4 @@
+.mana-view-container {
+  position: relative;
+  height: 100%;
+}