web-window-manager 1.0.3

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,87 @@
+"use strict";
+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;
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("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) {
+        const cache = this.getCache();
+        if ((0, lodash_1.isEmpty)(cache))
+            return;
+        this.hardSetCache(cache[__classPrivateFieldGet(this, _WindowManagerCache_win, "f").name].filter(name => item !== name));
+    }
+    addItemToCache(item) {
+        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((0, lodash_1.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) {
+        __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) {
+        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();
+exports.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: ({ link, name }: {
+        link: string;
+        name?: string | undefined;
+    }) => 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,122 @@
+"use strict";
+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;
+Object.defineProperty(exports, "__esModule", { value: true });
+const WindowManagerCache_1 = require("./WindowManagerCache");
+const lodash_1 = require("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 = ({ link, name }) => {
+            var _a, _b, _c;
+            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;
+            __classPrivateFieldSet(this, _WindowManager_children, (0, lodash_1.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 (this.hasChildren) {
+                const copy = [...__classPrivateFieldGet(this, _WindowManager_children, "f")];
+                (0, lodash_1.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_1.default(__classPrivateFieldGet(this, _WindowManager_win, "f")).init(), "f");
+            (0, lodash_1.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) {
+        __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) {
+        __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);
+        (0, lodash_1.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;
+exports.default = NewWindowManagerInstance;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "web-window-manager",
+  "version": "1.0.3",
+  "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",
+    "build": "npm run clean && tsc",
+    "fix": "npm run lint; npm run format",
+    "clean": "tsc --build --clean",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "tslint -p tsconfig.json"
+  },
+  "dependencies": {
+    "@types/lodash": "^4.14.185",
+    "lodash": "^4.17.21"
+  },
+  "files": [
+    "lib/**/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Tarmstrong95/WebWindowManager.git"
+  },
+  "keywords": [
+    "web",
+    "window",
+    "manager",
+    "helper"
+  ],
+  "bugs": {
+    "url": "https://github.com/Tarmstrong95/WebWindowManager/issues"
+  },
+  "homepage": "https://github.com/Tarmstrong95/WebWindowManager#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "devDependencies": {
+    "prettier": "^2.8.0",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typescript": "^4.9.3"
+  }
+}