horizon-layout 1.0.0

package/dist/utils.js

@@ -0,0 +1,248 @@
+import { SvelteMap } from 'svelte/reactivity';
+import { DEFAULT_MIN_WIDTH_RATIO, DEFAULT_MIN_HEIGHT_RATIO } from "./internal-utils.js";
+/// Remove a tab group that has become empty, then collapse any resulting
+/// single-child splits up the tree.
+export function simplifyTabGroup(tabGroup, nodeParentMap, config) {
+    if (tabGroup.tabs.length > 0)
+        return;
+    const parent = nodeParentMap.get(tabGroup);
+    if (!parent) {
+        config.root = undefined;
+        return;
+    }
+    parent.parent.views.splice(parent.index, 1);
+    parent.parent.splitPoints.splice(Math.min(parent.index, parent.parent.splitPoints.length - 1), 1);
+    /// Remove a split that has become a single view, then collapse any resulting
+    /// single-child splits up the tree.
+    const simplifySplit = (split) => {
+        if (split.views.length > 1)
+            return;
+        const only = split.views[0];
+        const splitParent = nodeParentMap.get(split);
+        if (splitParent) {
+            splitParent.parent.views[splitParent.index] = only;
+            simplifySplit(splitParent.parent);
+        }
+        else {
+            config.root = only;
+        }
+    };
+    simplifySplit(parent.parent);
+}
+/// returns 'split' if the config is a SplitConfig, or 'tabGroup' if it's a TabGroupConfig
+export function nodeConfigType(config) {
+    if ('splitPoints' in config) {
+        return 'split';
+    }
+    else {
+        return 'tabGroup';
+    }
+}
+export function buildNodeParentMap(root) {
+    const map = new SvelteMap();
+    function walk(node, parent = null) {
+        if (parent)
+            map.set(node, parent);
+        if (nodeConfigType(node) === 'split') {
+            const split = node;
+            for (let i = 0; i < split.views.length; i++) {
+                walk(split.views[i], { parent: split, index: i });
+            }
+        }
+    }
+    walk(root);
+    return map;
+}
+/// returns true if the two configs are equivalent (i.e. they represent the same layout), false otherwise
+export function areConfigsEquivalent(config1, config2) {
+    if (config1.maximizedView !== config2.maximizedView)
+        return false;
+    if ((config1.root === undefined) !== (config2.root === undefined))
+        return false;
+    const popouts1 = [...(config1.popouts ?? [])].sort();
+    const popouts2 = [...(config2.popouts ?? [])].sort();
+    if (popouts1.length !== popouts2.length)
+        return false;
+    for (let i = 0; i < popouts1.length; i++) {
+        if (popouts1[i] !== popouts2[i])
+            return false;
+    }
+    const areNodeConfigsEquivalent = (node1, node2) => {
+        const node_type = nodeConfigType(node1);
+        if (node_type !== nodeConfigType(node2))
+            return false;
+        return node_type === 'split'
+            ? areSplitConfigsEquivalent(node1, node2)
+            : areTabGroupConfigsEquivalent(node1, node2);
+    };
+    const areSplitConfigsEquivalent = (split1, split2) => {
+        if (split1.direction !== split2.direction)
+            return false;
+        if (split1.splitPoints.length !== split2.splitPoints.length)
+            return false;
+        for (let i = 0; i < split1.splitPoints.length; i++) {
+            if (split1.splitPoints[i] !== split2.splitPoints[i])
+                return false;
+        }
+        if (split1.views.length !== split2.views.length)
+            return false;
+        for (let i = 0; i < split1.views.length; i++) {
+            if (!areNodeConfigsEquivalent(split1.views[i], split2.views[i]))
+                return false;
+        }
+        return true;
+    };
+    const areTabGroupConfigsEquivalent = (tabGroup1, tabGroup2) => {
+        if (tabGroup1.activeTabIndex !== tabGroup2.activeTabIndex)
+            return false;
+        if (tabGroup1.tabs.length !== tabGroup2.tabs.length)
+            return false;
+        for (let i = 0; i < tabGroup1.tabs.length; i++) {
+            if (tabGroup1.tabs[i] !== tabGroup2.tabs[i])
+                return false;
+        }
+        return true;
+    };
+    // we can only check config1 because of the early return
+    // if ((config1.root === undefined) !== (config2.root === undefined)) return false;
+    if (config1.root === undefined)
+        return true;
+    return areNodeConfigsEquivalent(config1.root, config2.root);
+}
+/// Validates a LayoutConfig against a views map.
+/// Throws an Error if the config is invalid.
+/// Pass the same minWidthRatio / minHeightRatio you use for HorizonLayout so that
+/// split-point constraints are checked with the same thresholds.
+export function validateConfig(config, views, options = {}) {
+    const { minWidthRatio = DEFAULT_MIN_WIDTH_RATIO, minHeightRatio = DEFAULT_MIN_HEIGHT_RATIO } = options;
+    if (config.maximizedView && !views.get(config.maximizedView)) {
+        throw new Error(`unknown maximizedView id "${config.maximizedView}"`);
+    }
+    for (const id of config.popouts ?? []) {
+        if (!views.get(id))
+            throw new Error(`unknown popout id "${id}"`);
+    }
+    if (!config.root)
+        return;
+    const seenIds = new Set();
+    const validateTabGroup = (tabGroup) => {
+        if (tabGroup.activeTabIndex < 0 || tabGroup.activeTabIndex >= tabGroup.tabs.length) {
+            throw new Error('activeTabIndex out of range');
+        }
+        for (const id of tabGroup.tabs) {
+            if (!views.get(id))
+                throw new Error(`unknown tab id "${id}"`);
+            if (seenIds.has(id))
+                throw new Error(`duplicate tab id "${id}"`);
+            seenIds.add(id);
+        }
+    };
+    const validateSplit = (split) => {
+        if (split.splitPoints.length !== split.views.length - 1) {
+            throw new Error('splitPoints.length must equal views.length - 1');
+        }
+        const minRatio = split.direction === 'horizontal' ? minWidthRatio : minHeightRatio;
+        for (let i = 0; i < split.splitPoints.length; i++) {
+            const point = split.splitPoints[i];
+            const prev = split.splitPoints[i - 1] ?? 0;
+            if (point < prev + minRatio || point > 1 - minRatio) {
+                throw new Error('splitPoints violate minRatio constraints');
+            }
+        }
+        for (const child of split.views) {
+            validateNode(child);
+        }
+    };
+    const validateNode = (node) => nodeConfigType(node) === 'split'
+        ? validateSplit(node)
+        : validateTabGroup(node);
+    validateNode(config.root);
+}
+function parseNodeConfig(object, path) {
+    try {
+        return parseSplitConfig(object, path);
+    }
+    catch {
+        return parseTabGroupConfig(object, path);
+    }
+}
+function parseSplitConfig(object, path) {
+    if (typeof object !== 'object' || object === null)
+        throw new Error(`${path}: expected an object`);
+    const obj = object;
+    const { direction, views, splitPoints } = obj;
+    if (direction !== 'horizontal' && direction !== 'vertical')
+        throw new Error(`${path}.direction: expected "horizontal" or "vertical"`);
+    if (!Array.isArray(views) || views.length < 2)
+        throw new Error(`${path}.views: expected an array of at least 2 elements`);
+    if (!Array.isArray(splitPoints) || splitPoints.length < 1)
+        throw new Error(`${path}.splitPoints: expected a non-empty array`);
+    for (let i = 0; i < splitPoints.length; i++) {
+        if (typeof splitPoints[i] !== 'number')
+            throw new Error(`${path}.splitPoints[${i}]: expected a number`);
+    }
+    return {
+        direction,
+        views: views.map((v, i) => parseNodeConfig(v, `${path}.views[${i}]`)),
+        splitPoints: [...splitPoints]
+    };
+}
+function parseTabGroupConfig(object, path) {
+    if (typeof object !== 'object' || object === null)
+        throw new Error(`${path}: expected an object`);
+    const { tabs, activeTabIndex } = object;
+    if (!Array.isArray(tabs) || tabs.length < 1)
+        throw new Error(`${path}.tabs: expected a non-empty array`);
+    if (typeof activeTabIndex !== 'number')
+        throw new Error(`${path}.activeTabIndex: expected a number`);
+    return {
+        tabs: tabs.map((t, i) => parseId(t, `${path}.tabs[${i}]`)),
+        activeTabIndex
+    };
+}
+function parseId(object, path) {
+    if (!object || typeof object !== 'string')
+        throw new Error(`${path}: expected a non-empty string`);
+    return object;
+}
+/// Parses an unknown value (e.g. from JSON.parse) into a LayoutConfig,
+/// throwing an error if the value does not match the expected shape.
+export function parseLayoutConfig(object) {
+    if (typeof object !== 'object' || object === null)
+        throw new Error('root: expected an object');
+    const { root, maximizedView, popouts } = object;
+    const result = {};
+    if (root != null)
+        result.root = parseNodeConfig(root, 'config.root');
+    if (maximizedView != null)
+        result.maximizedView = parseId(maximizedView, 'config.maximizedView');
+    if (Array.isArray(popouts) && popouts.length > 0)
+        result.popouts = popouts.map((p, i) => parseId(p, `config.popouts[${i}]`));
+    return result;
+}
+/// returns a deep clone of the given config
+export function cloneConfig(config) {
+    const cloneNodeConfig = (node) => {
+        return nodeConfigType(node) === 'split'
+            ? cloneSplitConfig(node)
+            : cloneTabGroupConfig(node);
+    };
+    const cloneSplitConfig = (split) => {
+        return {
+            direction: split.direction,
+            views: split.views.map(cloneNodeConfig),
+            splitPoints: [...split.splitPoints]
+        };
+    };
+    const cloneTabGroupConfig = (tabGroup) => {
+        return {
+            tabs: [...tabGroup.tabs],
+            activeTabIndex: tabGroup.activeTabIndex
+        };
+    };
+    return {
+        ...(config.root ? { root: cloneNodeConfig(config.root) } : {}),
+        ...(config.maximizedView ? { maximizedView: config.maximizedView } : {}),
+        ...(config.popouts && config.popouts.length > 0 ? { popouts: [...config.popouts] } : {})
+    };
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "horizon-layout",
+  "version": "1.0.0",
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js"
+    },
+    "./horizon-layout.css": "./dist/horizon-layout.css"
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^2.1.0",
+    "@eslint/js": "^10.0.1",
+    "@sveltejs/adapter-auto": "^7.0.1",
+    "@sveltejs/kit": "^2.65.0",
+    "@sveltejs/package": "^2.5.8",
+    "@sveltejs/vite-plugin-svelte": "^7.1.2",
+    "@types/node": "^25.9.3",
+    "eslint": "^10.4.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-svelte": "^3.19.0",
+    "globals": "^17.6.0",
+    "prettier": "^3.8.4",
+    "prettier-plugin-svelte": "^3.5.2",
+    "publint": "^0.3.21",
+    "svelte": "^5.56.3",
+    "svelte-check": "^4.6.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.61.0",
+    "vite": "^8.0.16"
+  },
+  "keywords": [
+    "svelte"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "dev": "vite dev",
+    "build": "vite build && npm run prepack",
+    "preview": "vite preview",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
+    "lint": "prettier --check . && eslint .",
+    "format": "prettier --write ."
+  }
+}