web-window-manager 1.0.13 → 1.0.18

package/README.md

@@ -1,9 +1,3 @@
-<!-- PSA SECTION _____________________________ -->
-
-# PSA
-
-THIS PACKAGE IS NOT READY FOR USE IN YOUR PROJECTS
-
 <!-- TODO SECTION _____________________________ -->
 
 # TODO

package/lib/WindowManagerCache/index.d.ts

@@ -0,0 +1,29 @@
+import { CacheObject, WindowManagerCacheType } from './WindowManagerCache';
+declare class WindowManagerCache extends Object implements WindowManagerCacheType {
+    #private;
+    constructor(win: Window);
+    removeItemFromCache(item: string): void;
+    addItemToCache(item: string): void;
+    getCache(): CacheObject;
+    init(): this;
+    /**
+     * Takes in an array of window names and sets the key of `this.#win.name` to the new array
+     * @param data an array of window names
+     */
+    private hardSetCache;
+    /**
+     * sets the cache to an empty array
+     */
+    private clearCache;
+    /**
+     * Adds a CacheObject to session storage for window name persistance
+     * @param data the CacheObject to update the browser cache to
+     */
+    private updateStorage;
+    /**
+     * pulls the cache from session storage. If there is no cache, returns a falsy value
+     * @returns a CacheObject or undefined
+     */
+    private getFromStorage;
+}
+export default WindowManagerCache;

package/lib/WindowManagerCache/index.js

@@ -0,0 +1,93 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _WindowManagerCache_dataKey, _WindowManagerCache_win, _WindowManagerCache_cache;
+import { isEmpty, get } from 'lodash';
+class WindowManagerCache extends Object {
+    constructor(win) {
+        super();
+        _WindowManagerCache_dataKey.set(this, void 0);
+        _WindowManagerCache_win.set(this, void 0);
+        _WindowManagerCache_cache.set(this, void 0);
+        __classPrivateFieldSet(this, _WindowManagerCache_dataKey, 'window_manager_cache', "f");
+        __classPrivateFieldSet(this, _WindowManagerCache_win, win, "f");
+        __classPrivateFieldSet(this, _WindowManagerCache_cache, new Proxy({ [__classPrivateFieldGet(this, _WindowManagerCache_win, "f").name]: [] }, {
+            get: (target, property) => target[property],
+            set: (target, property, value) => {
+                target[property] = value;
+                this.updateStorage(target);
+                return true;
+            }
+        }), "f");
+    }
+    removeItemFromCache(item) {
+        if (typeof item !== 'string')
+            throw new TypeError('WindowManagerCache.removeItemFromCache() item must be a string');
+        const cache = this.getCache();
+        if (isEmpty(cache))
+            return;
+        this.hardSetCache(cache[__classPrivateFieldGet(this, _WindowManagerCache_win, "f").name].filter(name => item !== name));
+    }
+    addItemToCache(item) {
+        if (typeof item !== 'string')
+            throw new TypeError('WindowManagerCache.addItemFromCache() item must be a string');
+        const cache = this.getCache();
+        const temp = cache[__classPrivateFieldGet(this, _WindowManagerCache_win, "f").name];
+        cache[__classPrivateFieldGet(this, _WindowManagerCache_win, "f").name] = [...temp, item];
+    }
+    getCache() {
+        return __classPrivateFieldGet(this, _WindowManagerCache_cache, "f");
+    }
+    init() {
+        const cacheData = this.getFromStorage();
+        cacheData
+            ? this.hardSetCache(get(cacheData, __classPrivateFieldGet(this, _WindowManagerCache_win, "f").name, []))
+            : this.clearCache();
+        return this;
+    }
+    /**
+     * Takes in an array of window names and sets the key of `this.#win.name` to the new array
+     * @param data an array of window names
+     */
+    hardSetCache(data) {
+        if (typeof data !== 'object')
+            throw new TypeError('WindowManagerCache.hardSetCache() data must be an array of string');
+        __classPrivateFieldGet(this, _WindowManagerCache_cache, "f")[__classPrivateFieldGet(this, _WindowManagerCache_win, "f").name] = data;
+    }
+    /**
+     * sets the cache to an empty array
+     */
+    clearCache() {
+        this.hardSetCache([]);
+    }
+    /**
+     * Adds a CacheObject to session storage for window name persistance
+     * @param data the CacheObject to update the browser cache to
+     */
+    updateStorage(data) {
+        if (typeof data !== 'object')
+            throw new TypeError('WindowManagerCache.updateStorage() data must be an object');
+        sessionStorage.setItem(__classPrivateFieldGet(this, _WindowManagerCache_dataKey, "f"), JSON.stringify(data));
+    }
+    /**
+     * pulls the cache from session storage. If there is no cache, returns a falsy value
+     * @returns a CacheObject or undefined
+     */
+    getFromStorage() {
+        const data = sessionStorage.getItem(__classPrivateFieldGet(this, _WindowManagerCache_dataKey, "f"));
+        if (!data)
+            return;
+        const cache = JSON.parse(data);
+        return cache;
+    }
+}
+_WindowManagerCache_dataKey = new WeakMap(), _WindowManagerCache_win = new WeakMap(), _WindowManagerCache_cache = new WeakMap();
+export default WindowManagerCache;

package/lib/index.d.ts

@@ -0,0 +1,65 @@
+import { WindowManagerType } from './WindowManager';
+declare global {
+    interface Window {
+        /**
+         * A window manager that keeps track of all open child windows, opened by this instance.
+         * It is responsible for traversing the tree of windows and closing from furthest depth first.
+         *
+         * This class will instantiate itself and attach itself to the window object on first import
+         *
+         * Add an import to your entry file like so:
+         * ``` typescript
+         * import 'PATH_TO_WINDOW_MANAGER'
+         * ```
+         *
+         * Then use the managers available functions by accessing it via the window object
+         * ``` typescript
+         * window.WindowManager.CallFunction()
+         * ```
+         *
+         * @example ``` typescript
+         * // you can use this when logging out if you want to ensure all child windows are closed
+         * const logout = () => {
+         * // do some stuff
+         * window.WindowManager.recursivelyCloseChildren()
+         * }
+         * ```
+         */
+        WindowManager: WindowManager;
+    }
+}
+/**
+ * A window manager that keeps track of all open child windows, opened by this instance.
+ */
+declare class WindowManager implements WindowManagerType {
+    #private;
+    constructor(win: Window);
+    openWindow: (windowProperties: {
+        link: string;
+        name?: string;
+    }) => void;
+    popThisWindowFromParent: (childWindowName: string) => void;
+    recursivelyCloseChildren: (id?: number) => void;
+    newUnloadCallback(cb: () => void): void;
+    init: () => this;
+    /**
+     * Gets the length of `this.#children` and type casts it to boolean
+     * @returns boolean
+     */
+    private get hasChildren();
+    /**
+     * Calls `this.#win.close()` on this instance to close itself
+     */
+    private close;
+    /**
+     * Takes a window reference and adds it
+     */
+    private setChild;
+    /**
+     * Removes this window from the parent window's window manager.
+     * It calls each callback assigned to `this.#onUnloadCallbacks`
+     */
+    private handleUnload;
+}
+declare const NewWindowManagerInstance: WindowManager;
+export default NewWindowManagerInstance;

package/lib/index.js

@@ -0,0 +1,133 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _WindowManager_win, _WindowManager_newWindowDetails, _WindowManager_children, _WindowManager_windowManagerCache, _WindowManager_onUnloadCallbacks, _WindowManager_parent;
+import WindowManagerCache from './WindowManagerCache';
+import { remove, forEachRight, forEach } from 'lodash';
+/**
+ * A window manager that keeps track of all open child windows, opened by this instance.
+ */
+class WindowManager {
+    constructor(win) {
+        _WindowManager_win.set(this, void 0);
+        _WindowManager_newWindowDetails.set(this, void 0);
+        _WindowManager_children.set(this, void 0);
+        _WindowManager_windowManagerCache.set(this, void 0);
+        _WindowManager_onUnloadCallbacks.set(this, void 0);
+        _WindowManager_parent.set(this, void 0);
+        this.openWindow = (windowProperties) => {
+            var _a, _b, _c;
+            const { link, name } = windowProperties;
+            if (typeof link !== 'string')
+                throw new TypeError(`WindowManager.openWindow requires link to be given as a String`);
+            if (!['undefined', 'string'].includes(typeof name))
+                throw new TypeError(`WindowManager.openWindow requires name to be given as String or undefined`);
+            const childWindow = __classPrivateFieldGet(this, _WindowManager_win, "f").open(link, name || link, `
+        width=${__classPrivateFieldGet(this, _WindowManager_newWindowDetails, "f").WIDTH}, 
+        height=${__classPrivateFieldGet(this, _WindowManager_newWindowDetails, "f").HEIGHT}, 
+        left=${__classPrivateFieldGet(this, _WindowManager_newWindowDetails, "f").LEFT},
+        top=${__classPrivateFieldGet(this, _WindowManager_newWindowDetails, "f").TOP},
+        resizable=yes, 
+        scrollbars=yes
+       `);
+            if (!childWindow)
+                return;
+            this.setChild(childWindow);
+            if (link)
+                return (_a = __classPrivateFieldGet(this, _WindowManager_windowManagerCache, "f")) === null || _a === void 0 ? void 0 : _a.addItemToCache(childWindow.name);
+            if (((_b = childWindow.document) === null || _b === void 0 ? void 0 : _b.URL) !== 'about:blank')
+                return;
+            childWindow.close();
+            (_c = __classPrivateFieldGet(this, _WindowManager_windowManagerCache, "f")) === null || _c === void 0 ? void 0 : _c.removeItemFromCache(name);
+        };
+        this.popThisWindowFromParent = (childWindowName) => {
+            var _a;
+            if (typeof childWindowName !== 'string')
+                throw new TypeError('WindowManager.popThisWindowFromParent requires childWindowName to be given as a string');
+            __classPrivateFieldSet(this, _WindowManager_children, remove(__classPrivateFieldGet(this, _WindowManager_children, "f"), kid => kid.name !== childWindowName), "f");
+            (_a = __classPrivateFieldGet(this, _WindowManager_windowManagerCache, "f")) === null || _a === void 0 ? void 0 : _a.removeItemFromCache(childWindowName);
+        };
+        this.recursivelyCloseChildren = (id = 0) => {
+            if (typeof id !== 'number')
+                throw new TypeError('WindowManager.recursivelyCloseChildren requires id to be given as a number');
+            if (this.hasChildren) {
+                const copy = [...__classPrivateFieldGet(this, _WindowManager_children, "f")];
+                forEachRight(copy, child => {
+                    var _a;
+                    (_a = child === null || child === void 0 ? void 0 : child.WindowManager) === null || _a === void 0 ? void 0 : _a.recursivelyCloseChildren(id + 1);
+                });
+            }
+            if (!id)
+                return;
+            this.close();
+        };
+        this.init = () => {
+            window.addEventListener('beforeunload', e => this.handleUnload());
+            __classPrivateFieldGet(this, _WindowManager_win, "f").WindowManager = this;
+            if (!__classPrivateFieldGet(this, _WindowManager_win, "f").name)
+                __classPrivateFieldGet(this, _WindowManager_win, "f").name = 'main';
+            __classPrivateFieldSet(this, _WindowManager_windowManagerCache, new WindowManagerCache(__classPrivateFieldGet(this, _WindowManager_win, "f")).init(), "f");
+            forEach(__classPrivateFieldGet(this, _WindowManager_windowManagerCache, "f").getCache()[__classPrivateFieldGet(this, _WindowManager_win, "f").name], name => this.openWindow({ link: '', name }));
+            return this;
+        };
+        /**
+         * Calls `this.#win.close()` on this instance to close itself
+         */
+        this.close = () => {
+            const p = __classPrivateFieldGet(this, _WindowManager_parent, "f");
+            if (!!p)
+                p.WindowManager.popThisWindowFromParent(__classPrivateFieldGet(this, _WindowManager_win, "f").name);
+            __classPrivateFieldGet(this, _WindowManager_win, "f").close();
+        };
+        __classPrivateFieldSet(this, _WindowManager_win, win, "f");
+        __classPrivateFieldSet(this, _WindowManager_parent, win.opener, "f");
+        __classPrivateFieldSet(this, _WindowManager_children, [], "f");
+        __classPrivateFieldSet(this, _WindowManager_onUnloadCallbacks, [], "f");
+        __classPrivateFieldSet(this, _WindowManager_newWindowDetails, {
+            WIDTH: 900,
+            HEIGHT: 600,
+            LEFT: 0,
+            RIGHT: 0
+        }, "f");
+    }
+    newUnloadCallback(cb) {
+        if (typeof cb !== 'function')
+            throw new TypeError('Windowmanager.newUnloadCallback requires cb to be given as a function');
+        __classPrivateFieldGet(this, _WindowManager_onUnloadCallbacks, "f").push(cb);
+    }
+    /**
+     * Gets the length of `this.#children` and type casts it to boolean
+     * @returns boolean
+     */
+    get hasChildren() {
+        return !!__classPrivateFieldGet(this, _WindowManager_children, "f").length;
+    }
+    /**
+     * Takes a window reference and adds it
+     */
+    setChild(child) {
+        if (typeof child !== 'object' || !child)
+            throw new TypeError('WindowManager.setChild requires child to be a Window object');
+        __classPrivateFieldSet(this, _WindowManager_children, [...new Set([...__classPrivateFieldGet(this, _WindowManager_children, "f"), child])].filter(kid => !kid.closed), "f");
+    }
+    /**
+     * Removes this window from the parent window's window manager.
+     * It calls each callback assigned to `this.#onUnloadCallbacks`
+     */
+    handleUnload() {
+        __classPrivateFieldGet(this, _WindowManager_parent, "f").WindowManager.popThisWindowFromParent(__classPrivateFieldGet(this, _WindowManager_win, "f").name);
+        forEach(__classPrivateFieldGet(this, _WindowManager_onUnloadCallbacks, "f"), cb => cb());
+    }
+}
+_WindowManager_win = new WeakMap(), _WindowManager_newWindowDetails = new WeakMap(), _WindowManager_children = new WeakMap(), _WindowManager_windowManagerCache = new WeakMap(), _WindowManager_onUnloadCallbacks = new WeakMap(), _WindowManager_parent = new WeakMap();
+const NewWindowManagerInstance = new WindowManager(window).init();
+window.WindowManager = NewWindowManagerInstance;
+export default NewWindowManagerInstance;

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "web-window-manager",
-  "version": "1.0.13",
+  "version": "1.0.18",
   "description": "A window manager for maintaining window parent child relationships",
   "main": "lib/index.js",
   "author": "Triston Armstrong",
   "license": "MIT",
   "scripts": {
     "start": "tsc --watch",
-    "prepublishOnly": "npm run fix",
-    "publish": "npm run build",
+    "prepublishOnly": "npm run fix; npm run build",
     "build": "npm run clean && tsc",
     "fix": "npm run lint; npm run format",
     "clean": "tsc --build --clean",