@ringcentral/juno 1.11.2 → 1.11.3-beta.5620-d9154e6b

package/components/PortalHost/PortalManager/PortalStore.d.ts

@@ -0,0 +1,20 @@
+import { UniqID, PortalDescriptor } from './types';
+import { Connectable } from '../Connectable';
+export declare class PortalStore<D extends {}> extends Connectable<PortalDescriptor<D>[]> {
+    private readonly _portalMap;
+    private _batchMode;
+    get size(): number;
+    get lastPortal(): PortalDescriptor<D, {}, any> | undefined;
+    get portals(): IterableIterator<PortalDescriptor<D, {}, any>>;
+    addOrUpdate(portal: PortalDescriptor<D>): void;
+    delete(id: UniqID): void;
+    clear(): void;
+    has(id: UniqID): boolean;
+    get(id: UniqID): PortalDescriptor<D, {}, any> | undefined;
+    batch(handle: (store: PortalStore<D>) => void): void;
+    /**
+     * just notify portal host rerender view
+     */
+    forceEmit(): void;
+    private _emitChanges;
+}

package/components/PortalHost/PortalManager/PortalStore.js

@@ -0,0 +1,134 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Connectable_1 = require("../Connectable");
+var PortalStore = /** @class */ (function (_super) {
+    __extends(PortalStore, _super);
+    function PortalStore() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this._portalMap = new Map();
+        _this._batchMode = false;
+        return _this;
+    }
+    Object.defineProperty(PortalStore.prototype, "size", {
+        get: function () {
+            return this._portalMap.size;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PortalStore.prototype, "lastPortal", {
+        get: function () {
+            var e_1, _a;
+            var lastPortal;
+            try {
+                for (var _b = __values(this.portals), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var portal = _c.value;
+                    lastPortal = portal;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return lastPortal;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(PortalStore.prototype, "portals", {
+        get: function () {
+            return this._portalMap.values();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    PortalStore.prototype.addOrUpdate = function (portal) {
+        this._portalMap.set(portal.id, portal);
+        if (!this._batchMode)
+            this._emitChanges();
+    };
+    PortalStore.prototype.delete = function (id) {
+        this._portalMap.delete(id);
+        if (!this._batchMode)
+            this._emitChanges();
+    };
+    PortalStore.prototype.clear = function () {
+        this._portalMap.clear();
+        if (!this._batchMode)
+            this._emitChanges();
+    };
+    PortalStore.prototype.has = function (id) {
+        return this._portalMap.has(id);
+    };
+    PortalStore.prototype.get = function (id) {
+        return this._portalMap.get(id);
+    };
+    PortalStore.prototype.batch = function (handle) {
+        this._batchMode = true;
+        try {
+            handle(this);
+        }
+        finally {
+            this._batchMode = false;
+            this._emitChanges();
+        }
+    };
+    /**
+     * just notify portal host rerender view
+     */
+    PortalStore.prototype.forceEmit = function () {
+        this._emitChanges();
+    };
+    PortalStore.prototype._emitChanges = function () {
+        this.emit(__spread(this.portals));
+    };
+    return PortalStore;
+}(Connectable_1.Connectable));
+exports.PortalStore = PortalStore;

package/components/PortalHost/PortalManager/index.d.ts

@@ -0,0 +1,4 @@
+export * from './PortalManager';
+export * from './PortalStore';
+export * from './types';
+export * from './utils';

package/components/PortalHost/PortalManager/index.js

@@ -0,0 +1,9 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./PortalManager"));
+__export(require("./PortalStore"));
+__export(require("./types"));
+__export(require("./utils"));

package/components/PortalHost/PortalManager/types.d.ts

@@ -0,0 +1,86 @@
+import { ComponentType, Key } from 'react';
+export declare type PortalDescriptor<D extends {} = {}, P extends {} = {}, F = any> = {
+    readonly id: UniqID;
+    readonly Component: ComponentType;
+    /**
+     * lifecycle hook
+     */
+    readonly onMounted: () => void;
+    /**
+     * lifecycle hook
+     */
+    readonly onUnmounted: () => void;
+    /**
+     * pass to component. component can call this fn to close self
+     */
+    readonly onClose: (feedback: any) => void;
+    /**
+     * mutable object
+     */
+    readonly portalController: PortalController<P, F, D>;
+    props?: {};
+    /**
+     * pass to component.
+     */
+    open: boolean;
+};
+export declare type createPortalDescriptorProps<P extends {}, F, D extends {}> = {
+    id: UniqID;
+    Component: ComponentType<ControlledProps<P, F>>;
+    props?: UncontrolledProps<P>;
+    data?: D;
+};
+export interface PortalController<P extends {} = {}, F = any, D extends {} = {}> {
+    id: UniqID;
+    /**
+     * resolve after portal mounted
+     */
+    onOpened: Promise<void>;
+    /**
+     * resolve after portal unmounted
+     */
+    onClosed: Promise<F | undefined>;
+    /**
+     * close portal
+     * @param feedback onClosed will resolve this feedback value
+     */
+    close(feedback?: F): void;
+    /**
+     * update props
+     * @param newProps will cover old props
+     */
+    updateProps: (newProps: UncontrolledProps<P>) => void;
+    /**
+     * check if it's opened
+     */
+    readonly isOpened: boolean;
+    /**
+     * check if it's on top
+     */
+    readonly isTop: boolean;
+    /**
+     * custom data
+     */
+    readonly data?: D;
+}
+export declare type ControlledProps<P extends {} = {}, F = undefined> = P & {
+    onClose: (feedback?: F) => void;
+    open: boolean;
+};
+export declare type UncontrolledProps<P extends {}> = Omit<P, 'onClose' | 'open'>;
+export declare type PortalOptions<P, D> = {
+    /**
+     * props without 'onClose' and 'open'
+     */
+    props?: UncontrolledProps<P>;
+    /**
+     * manager will generate id if no provide id
+     */
+    id?: UniqID;
+    /**
+     * custom data
+     */
+    data?: D;
+};
+export declare type UniqID = Key;
+export declare const UnmountSymbol: unique symbol;

package/components/PortalHost/PortalManager/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnmountSymbol = Symbol('UmountPortal');

package/components/PortalHost/PortalManager/utils.d.ts

@@ -0,0 +1,8 @@
+import { UniqID } from './types';
+declare type ResolveFn<T> = (value: T | PromiseLike<T>) => void;
+export declare const createPromise: <T>() => [Promise<T>, ResolveFn<T>];
+export declare class UniqIdUtil {
+    private _currentNumber;
+    get(): UniqID;
+}
+export {};

package/components/PortalHost/PortalManager/utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPromise = function () {
+    var resolvePromise = null;
+    var promise = new Promise(function (resolve) {
+        resolvePromise = resolve;
+    });
+    return [promise, resolvePromise];
+};
+var UniqIdUtil = /** @class */ (function () {
+    function UniqIdUtil() {
+        this._currentNumber = 0;
+    }
+    UniqIdUtil.prototype.get = function () {
+        return String(this._currentNumber++);
+    };
+    return UniqIdUtil;
+}());
+exports.UniqIdUtil = UniqIdUtil;

package/components/PortalHost/PortalRenderer.d.ts

@@ -0,0 +1,10 @@
+import { FunctionComponent } from 'react';
+import { PortalDescriptor } from './PortalManager';
+declare type RcPortalRendererProps = {
+    portalDescriptor: PortalDescriptor;
+};
+/**
+ * private, do not use this directly
+ */
+declare const RcPortalRenderer: FunctionComponent<RcPortalRendererProps>;
+export { RcPortalRenderer, RcPortalRendererProps };

package/components/PortalHost/PortalRenderer.js

@@ -0,0 +1,43 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = __importStar(require("react"));
+var context_1 = require("./context");
+/**
+ * private, do not use this directly
+ */
+var RcPortalRenderer = function (_a) {
+    var portalDescriptor = _a.portalDescriptor;
+    var Component = portalDescriptor.Component, _props = portalDescriptor.props, onMounted = portalDescriptor.onMounted, onUnmounted = portalDescriptor.onUnmounted, onClose = portalDescriptor.onClose, open = portalDescriptor.open, id = portalDescriptor.id;
+    react_1.useEffect(function () {
+        onMounted();
+        return function () { return onUnmounted(); };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    var element = react_1.useMemo(function () {
+        // onClose, open must be covered
+        var props = __assign(__assign({}, _props), { onClose: onClose, open: open });
+        return react_1.default.createElement(Component, __assign({}, props));
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [_props, open]);
+    return react_1.default.createElement(context_1.PortalIDProvider, { value: id }, element);
+};
+exports.RcPortalRenderer = RcPortalRenderer;
+RcPortalRenderer.displayName = 'RcPortalRenderer';

package/components/PortalHost/context/PortalIDContext.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+/// <reference types="styled-jsx" />
+/// <reference types="@emotion/core" />
+export declare const PortalIDContext: import("react").Context<string | number | undefined>;
+export declare const PortalIDProvider: import("react").Provider<string | number | undefined>;

package/components/PortalHost/context/PortalIDContext.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+exports.PortalIDContext = react_1.createContext(undefined);
+exports.PortalIDProvider = exports.PortalIDContext.Provider;

package/components/PortalHost/context/PortalManagerContext.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+/// <reference types="styled-jsx" />
+/// <reference types="@emotion/core" />
+import { PortalManager } from '../PortalManager';
+export declare const PortalManagerContext: import("react").Context<PortalManager<{}> | undefined>;
+export declare const PortalManagerProvider: import("react").Provider<PortalManager<{}> | undefined>;

package/components/PortalHost/context/PortalManagerContext.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+exports.PortalManagerContext = react_1.createContext(undefined);
+exports.PortalManagerProvider = exports.PortalManagerContext.Provider;

package/components/PortalHost/context/index.d.ts

@@ -0,0 +1,2 @@
+export * from './PortalIDContext';
+export * from './PortalManagerContext';

package/components/PortalHost/context/index.js

@@ -0,0 +1,7 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./PortalIDContext"));
+__export(require("./PortalManagerContext"));

package/components/PortalHost/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Connectable';
+export * from './PortalHost';
+export * from './PortalManager';
+export * from './utils';

package/components/PortalHost/index.js

@@ -0,0 +1,9 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./Connectable"));
+__export(require("./PortalHost"));
+__export(require("./PortalManager"));
+__export(require("./utils"));

package/components/PortalHost/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './usePortalManagerWithID';
+export * from './useUnmountPortalHandler';

package/components/PortalHost/utils/index.js

@@ -0,0 +1,7 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./usePortalManagerWithID"));
+__export(require("./useUnmountPortalHandler"));

package/components/PortalHost/utils/usePortalManagerWithID.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+/// <reference types="styled-jsx" />
+/// <reference types="@emotion/core" />
+import { PortalManager } from '../PortalManager';
+export declare const usePortalManagerWithID: <M extends PortalManager<{}> = PortalManager<{}>>() => {
+    manager: M;
+    id: import("react").ReactText;
+} | undefined;

package/components/PortalHost/utils/usePortalManagerWithID.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var react_1 = require("react");
+var context_1 = require("../context");
+exports.usePortalManagerWithID = function () {
+    var manager = react_1.useContext(context_1.PortalManagerContext);
+    var id = react_1.useContext(context_1.PortalIDContext);
+    if (manager && id !== undefined) {
+        return { manager: manager, id: id };
+    }
+    return undefined;
+};