@jxsuite/studio 2.0.0 → 2.1.0

package/dist/chunks/{studio-cx91mnh8.js → studio-ckwz4d3x.js}

@@ -2,59 +2,14 @@ import {
   Directive,
   PartType,
   directive
-} from "./studio-4k0m4fmp.js";
+} from "./studio-p471gg5n.js";
 import {
   noChange,
   nothing
 } from "./studio-5x5774ak.js";
 
-// ../../node_modules/lit-html/development/directives/class-map.js
-class ClassMapDirective extends Directive {
-  constructor(partInfo) {
-    super(partInfo);
-    if (partInfo.type !== PartType.ATTRIBUTE || partInfo.name !== "class" || partInfo.strings?.length > 2) {
-      throw new Error("`classMap()` can only be used in the `class` attribute " + "and must be the only part in the attribute.");
-    }
-  }
-  render(classInfo) {
-    return " " + Object.keys(classInfo).filter((key) => classInfo[key]).join(" ") + " ";
-  }
-  update(part, [classInfo]) {
-    if (this._previousClasses === undefined) {
-      this._previousClasses = new Set;
-      if (part.strings !== undefined) {
-        this._staticClasses = new Set(part.strings.join(" ").split(/\s/).filter((s) => s !== ""));
-      }
-      for (const name in classInfo) {
-        if (classInfo[name] && !this._staticClasses?.has(name)) {
-          this._previousClasses.add(name);
-        }
-      }
-      return this.render(classInfo);
-    }
-    const classList = part.element.classList;
-    for (const name of this._previousClasses) {
-      if (!(name in classInfo)) {
-        classList.remove(name);
-        this._previousClasses.delete(name);
-      }
-    }
-    for (const name in classInfo) {
-      const value = !!classInfo[name];
-      if (value !== this._previousClasses.has(name) && !this._staticClasses?.has(name)) {
-        if (value) {
-          classList.add(name);
-          this._previousClasses.add(name);
-        } else {
-          classList.remove(name);
-          this._previousClasses.delete(name);
-        }
-      }
-    }
-    return noChange;
-  }
-}
-var classMap = directive(ClassMapDirective);
+// ../../node_modules/lit-html/development/directives/if-defined.js
+var ifDefined = (value) => value ?? nothing;
 
 // ../../node_modules/lit-html/development/directives/style-map.js
 var important = "important";
@@ -111,10 +66,55 @@ class StyleMapDirective extends Directive {
 }
 var styleMap = directive(StyleMapDirective);
 
-// ../../node_modules/lit-html/development/directives/if-defined.js
-var ifDefined = (value) => value ?? nothing;
+// ../../node_modules/lit-html/development/directives/class-map.js
+class ClassMapDirective extends Directive {
+  constructor(partInfo) {
+    super(partInfo);
+    if (partInfo.type !== PartType.ATTRIBUTE || partInfo.name !== "class" || partInfo.strings?.length > 2) {
+      throw new Error("`classMap()` can only be used in the `class` attribute " + "and must be the only part in the attribute.");
+    }
+  }
+  render(classInfo) {
+    return " " + Object.keys(classInfo).filter((key) => classInfo[key]).join(" ") + " ";
+  }
+  update(part, [classInfo]) {
+    if (this._previousClasses === undefined) {
+      this._previousClasses = new Set;
+      if (part.strings !== undefined) {
+        this._staticClasses = new Set(part.strings.join(" ").split(/\s/).filter((s) => s !== ""));
+      }
+      for (const name in classInfo) {
+        if (classInfo[name] && !this._staticClasses?.has(name)) {
+          this._previousClasses.add(name);
+        }
+      }
+      return this.render(classInfo);
+    }
+    const classList = part.element.classList;
+    for (const name of this._previousClasses) {
+      if (!(name in classInfo)) {
+        classList.remove(name);
+        this._previousClasses.delete(name);
+      }
+    }
+    for (const name in classInfo) {
+      const value = !!classInfo[name];
+      if (value !== this._previousClasses.has(name) && !this._staticClasses?.has(name)) {
+        if (value) {
+          classList.add(name);
+          this._previousClasses.add(name);
+        } else {
+          classList.remove(name);
+          this._previousClasses.delete(name);
+        }
+      }
+    }
+    return noChange;
+  }
+}
+var classMap = directive(ClassMapDirective);
 
-export { classMap, styleMap, ifDefined };
+export { ifDefined, styleMap, classMap };
 
-//# debugId=69E323004940924164756E2164756E21
-//# sourceMappingURL=studio-cx91mnh8.js.map
+//# debugId=A0F1689B5230596A64756E2164756E21
+//# sourceMappingURL=studio-ckwz4d3x.js.map

package/dist/chunks/{studio-cx91mnh8.js.map → studio-ckwz4d3x.js.map}

@@ -1,12 +1,12 @@
 {
   "version": 3,
-  "sources": ["../../../node_modules/lit-html/development/directives/class-map.js", "../../../node_modules/lit-html/development/directives/style-map.js", "../../../node_modules/lit-html/development/directives/if-defined.js"],
+  "sources": ["../../../node_modules/lit-html/development/directives/if-defined.js", "../../../node_modules/lit-html/development/directives/style-map.js", "../../../node_modules/lit-html/development/directives/class-map.js"],
   "sourcesContent": [
-    "/**\n * @license\n * Copyright 2018 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport { noChange } from '../lit-html.js';\nimport { directive, Directive, PartType, } from '../directive.js';\nclass ClassMapDirective extends Directive {\n    constructor(partInfo) {\n        super(partInfo);\n        if (partInfo.type !== PartType.ATTRIBUTE ||\n            partInfo.name !== 'class' ||\n            partInfo.strings?.length > 2) {\n            throw new Error('`classMap()` can only be used in the `class` attribute ' +\n                'and must be the only part in the attribute.');\n        }\n    }\n    render(classInfo) {\n        // Add spaces to ensure separation from static classes\n        return (' ' +\n            Object.keys(classInfo)\n                .filter((key) => classInfo[key])\n                .join(' ') +\n            ' ');\n    }\n    update(part, [classInfo]) {\n        // Remember dynamic classes on the first render\n        if (this._previousClasses === undefined) {\n            this._previousClasses = new Set();\n            if (part.strings !== undefined) {\n                this._staticClasses = new Set(part.strings\n                    .join(' ')\n                    .split(/\\s/)\n                    .filter((s) => s !== ''));\n            }\n            for (const name in classInfo) {\n                if (classInfo[name] && !this._staticClasses?.has(name)) {\n                    this._previousClasses.add(name);\n                }\n            }\n            return this.render(classInfo);\n        }\n        const classList = part.element.classList;\n        // Remove old classes that no longer apply\n        for (const name of this._previousClasses) {\n            if (!(name in classInfo)) {\n                classList.remove(name);\n                this._previousClasses.delete(name);\n            }\n        }\n        // Add or remove classes based on their classMap value\n        for (const name in classInfo) {\n            // We explicitly want a loose truthy check of `value` because it seems\n            // more convenient that '' and 0 are skipped.\n            const value = !!classInfo[name];\n            if (value !== this._previousClasses.has(name) &&\n                !this._staticClasses?.has(name)) {\n                if (value) {\n                    classList.add(name);\n                    this._previousClasses.add(name);\n                }\n                else {\n                    classList.remove(name);\n                    this._previousClasses.delete(name);\n                }\n            }\n        }\n        return noChange;\n    }\n}\n/**\n * A directive that applies dynamic CSS classes.\n *\n * This must be used in the `class` attribute and must be the only part used in\n * the attribute. It takes each property in the `classInfo` argument and adds\n * the property name to the element's `classList` if the property value is\n * truthy; if the property value is falsy, the property name is removed from\n * the element's `class`.\n *\n * For example `{foo: bar}` applies the class `foo` if the value of `bar` is\n * truthy.\n *\n * @param classInfo\n */\nexport const classMap = directive(ClassMapDirective);\n//# sourceMappingURL=class-map.js.map",
+    "/**\n * @license\n * Copyright 2018 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport { nothing } from '../lit-html.js';\n/**\n * For AttributeParts, sets the attribute if the value is defined and removes\n * the attribute if the value is undefined.\n *\n * For other part types, this directive is a no-op.\n */\nexport const ifDefined = (value) => value ?? nothing;\n//# sourceMappingURL=if-defined.js.map",
     "/**\n * @license\n * Copyright 2018 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport { noChange } from '../lit-html.js';\nimport { directive, Directive, PartType, } from '../directive.js';\nconst important = 'important';\n// The leading space is important\nconst importantFlag = ' !' + important;\n// How many characters to remove from a value, as a negative number\nconst flagTrim = 0 - importantFlag.length;\nclass StyleMapDirective extends Directive {\n    constructor(partInfo) {\n        super(partInfo);\n        if (partInfo.type !== PartType.ATTRIBUTE ||\n            partInfo.name !== 'style' ||\n            partInfo.strings?.length > 2) {\n            throw new Error('The `styleMap` directive must be used in the `style` attribute ' +\n                'and must be the only part in the attribute.');\n        }\n    }\n    render(styleInfo) {\n        return Object.keys(styleInfo).reduce((style, prop) => {\n            const value = styleInfo[prop];\n            if (value == null) {\n                return style;\n            }\n            // Convert property names from camel-case to dash-case, i.e.:\n            //  `backgroundColor` -> `background-color`\n            // Vendor-prefixed names need an extra `-` appended to front:\n            //  `webkitAppearance` -> `-webkit-appearance`\n            // Exception is any property name containing a dash, including\n            // custom properties; we assume these are already dash-cased i.e.:\n            //  `--my-button-color` --> `--my-button-color`\n            prop = prop.includes('-')\n                ? prop\n                : prop\n                    .replace(/(?:^(webkit|moz|ms|o)|)(?=[A-Z])/g, '-$&')\n                    .toLowerCase();\n            return style + `${prop}:${value};`;\n        }, '');\n    }\n    update(part, [styleInfo]) {\n        const { style } = part.element;\n        if (this._previousStyleProperties === undefined) {\n            this._previousStyleProperties = new Set(Object.keys(styleInfo));\n            return this.render(styleInfo);\n        }\n        // Remove old properties that no longer exist in styleInfo\n        for (const name of this._previousStyleProperties) {\n            // If the name isn't in styleInfo or it's null/undefined\n            if (styleInfo[name] == null) {\n                this._previousStyleProperties.delete(name);\n                if (name.includes('-')) {\n                    style.removeProperty(name);\n                }\n                else {\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    style[name] = null;\n                }\n            }\n        }\n        // Add or update properties\n        for (const name in styleInfo) {\n            const value = styleInfo[name];\n            if (value != null) {\n                this._previousStyleProperties.add(name);\n                const isImportant = typeof value === 'string' && value.endsWith(importantFlag);\n                if (name.includes('-') || isImportant) {\n                    style.setProperty(name, isImportant\n                        ? value.slice(0, flagTrim)\n                        : value, isImportant ? important : '');\n                }\n                else {\n                    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                    style[name] = value;\n                }\n            }\n        }\n        return noChange;\n    }\n}\n/**\n * A directive that applies CSS properties to an element.\n *\n * `styleMap` can only be used in the `style` attribute and must be the only\n * expression in the attribute. It takes the property names in the\n * {@link StyleInfo styleInfo} object and adds the properties to the inline\n * style of the element.\n *\n * Property names with dashes (`-`) are assumed to be valid CSS\n * property names and set on the element's style object using `setProperty()`.\n * Names without dashes are assumed to be camelCased JavaScript property names\n * and set on the element's style object using property assignment, allowing the\n * style object to translate JavaScript-style names to CSS property names.\n *\n * For example `styleMap({backgroundColor: 'red', 'border-top': '5px', '--size':\n * '0'})` sets the `background-color`, `border-top` and `--size` properties.\n *\n * @param styleInfo\n * @see {@link https://lit.dev/docs/templates/directives/#stylemap styleMap code samples on Lit.dev}\n */\nexport const styleMap = directive(StyleMapDirective);\n//# sourceMappingURL=style-map.js.map",
-    "/**\n * @license\n * Copyright 2018 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport { nothing } from '../lit-html.js';\n/**\n * For AttributeParts, sets the attribute if the value is defined and removes\n * the attribute if the value is undefined.\n *\n * For other part types, this directive is a no-op.\n */\nexport const ifDefined = (value) => value ?? nothing;\n//# sourceMappingURL=if-defined.js.map"
+    "/**\n * @license\n * Copyright 2018 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport { noChange } from '../lit-html.js';\nimport { directive, Directive, PartType, } from '../directive.js';\nclass ClassMapDirective extends Directive {\n    constructor(partInfo) {\n        super(partInfo);\n        if (partInfo.type !== PartType.ATTRIBUTE ||\n            partInfo.name !== 'class' ||\n            partInfo.strings?.length > 2) {\n            throw new Error('`classMap()` can only be used in the `class` attribute ' +\n                'and must be the only part in the attribute.');\n        }\n    }\n    render(classInfo) {\n        // Add spaces to ensure separation from static classes\n        return (' ' +\n            Object.keys(classInfo)\n                .filter((key) => classInfo[key])\n                .join(' ') +\n            ' ');\n    }\n    update(part, [classInfo]) {\n        // Remember dynamic classes on the first render\n        if (this._previousClasses === undefined) {\n            this._previousClasses = new Set();\n            if (part.strings !== undefined) {\n                this._staticClasses = new Set(part.strings\n                    .join(' ')\n                    .split(/\\s/)\n                    .filter((s) => s !== ''));\n            }\n            for (const name in classInfo) {\n                if (classInfo[name] && !this._staticClasses?.has(name)) {\n                    this._previousClasses.add(name);\n                }\n            }\n            return this.render(classInfo);\n        }\n        const classList = part.element.classList;\n        // Remove old classes that no longer apply\n        for (const name of this._previousClasses) {\n            if (!(name in classInfo)) {\n                classList.remove(name);\n                this._previousClasses.delete(name);\n            }\n        }\n        // Add or remove classes based on their classMap value\n        for (const name in classInfo) {\n            // We explicitly want a loose truthy check of `value` because it seems\n            // more convenient that '' and 0 are skipped.\n            const value = !!classInfo[name];\n            if (value !== this._previousClasses.has(name) &&\n                !this._staticClasses?.has(name)) {\n                if (value) {\n                    classList.add(name);\n                    this._previousClasses.add(name);\n                }\n                else {\n                    classList.remove(name);\n                    this._previousClasses.delete(name);\n                }\n            }\n        }\n        return noChange;\n    }\n}\n/**\n * A directive that applies dynamic CSS classes.\n *\n * This must be used in the `class` attribute and must be the only part used in\n * the attribute. It takes each property in the `classInfo` argument and adds\n * the property name to the element's `classList` if the property value is\n * truthy; if the property value is falsy, the property name is removed from\n * the element's `class`.\n *\n * For example `{foo: bar}` applies the class `foo` if the value of `bar` is\n * truthy.\n *\n * @param classInfo\n */\nexport const classMap = directive(ClassMapDirective);\n//# sourceMappingURL=class-map.js.map"
   ],
-  "mappings": "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",
-  "debugId": "69E323004940924164756E2164756E21",
+  "mappings": "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",
+  "debugId": "A0F1689B5230596A64756E2164756E21",
   "names": []
 }

package/dist/chunks/studio-dg7zyt5x.js

@@ -0,0 +1,28 @@
+// ../collab/src/negotiate.ts
+var COLLAB_SUBPROTOCOL = "jx.collab.v1";
+function negotiateCollab(probe) {
+  if (probe === null || typeof probe !== "object") {
+    return { offer: [], refused: null };
+  }
+  const body = probe;
+  if (body.collab === false) {
+    return { offer: [], refused: "This server has collaboration disabled." };
+  }
+  const { protocols } = body;
+  if (!Array.isArray(protocols) || protocols.length === 0) {
+    return { offer: [], refused: null };
+  }
+  if (protocols.includes(COLLAB_SUBPROTOCOL)) {
+    return { offer: [COLLAB_SUBPROTOCOL], refused: null };
+  }
+  const theirs = protocols.filter((p) => typeof p === "string").join(", ") || "none";
+  return {
+    offer: [],
+    refused: `This server speaks collab envelope ${theirs}; this editor speaks ${COLLAB_SUBPROTOCOL}.`
+  };
+}
+
+export { negotiateCollab };
+
+//# debugId=0E14F1DBFFC9648B64756E2164756E21
+//# sourceMappingURL=studio-dg7zyt5x.js.map

package/dist/chunks/studio-dg7zyt5x.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../collab/src/negotiate.ts"],
+  "sourcesContent": [
+    "/**\n * WebSocket subprotocol negotiation for the collab socket (RFC 6455 §1.9, §4.2.2).\n *\n * **The token names the wire envelope, not the package.** `jx.collab.v1` means \"I speak the frame\n * layout `envelope.ts` documents\". There is one token per envelope **major**, and the rule for\n * bumping it is narrow on purpose: bump when {@link decodeFrame} would _mis-parse_ a peer's frame —\n * a field reordered, a type widened, a length prefix changed. **Do not bump for a new frame type.**\n * Both halves already skip a frame type they do not know, so a v1 peer and a v1-plus-one-frame peer\n * interoperate; bumping there would refuse a room that would have worked.\n *\n * **Why the capability probe does the negotiating.** RFC 6455 §4.1 requires a client that offered\n * subprotocols and received no echo to _fail the connection_, and browsers enforce it. So a new\n * Studio that unconditionally offered `jx.collab.v1` would lose collab entirely against an older\n * dev server — a regression caused by the fix. The probe already exists, already returns a version\n * the client discards, and runs before the socket: it is the one place the client can learn what\n * the server speaks without risking the handshake. Hence {@link negotiateCollab}, which turns a\n * probe body into the list to offer — empty against a server that advertises nothing.\n *\n * **Nothing here may go in the `hello` control message.** That arrives after the socket is up and\n * after frames may already have been exchanged, which is too late to prevent the divergent-history\n * merge `schema.ts` warns about. Negotiation has to conclude before a byte of document state\n * moves.\n *\n * This module imports nothing, deliberately: the Studio platform adapters read it eagerly, before\n * the dynamic import that pulls in Yjs, so it must not drag the CRDT into the initial bundle.\n */\n\n/** The subprotocol token for the envelope in `envelope.ts`. One token per envelope major. */\nexport const COLLAB_SUBPROTOCOL = \"jx.collab.v1\";\n\n/** What the client should do with the socket, given what the server advertised. */\nexport interface CollabNegotiation {\n  /**\n   * The subprotocols to offer as `Sec-WebSocket-Protocol`. **Empty means offer none**, which is the\n   * correct answer against a server that advertises none: an offer it cannot echo would fail the\n   * handshake outright, where offering nothing connects exactly as it does today.\n   */\n  offer: string[];\n  /**\n   * Non-null when the peers cannot interoperate: the server advertised subprotocols and none of\n   * them is one we speak. The client must not connect — the string says which side speaks what, so\n   * the degradation is legible rather than a silent solo session.\n   */\n  refused: string | null;\n}\n\n/**\n * Decide what to offer, from the body of a `GET /__studio/collab` capability probe.\n *\n * @param {unknown} probe The parsed probe body, or null if it did not parse as JSON.\n * @returns {CollabNegotiation}\n */\nexport function negotiateCollab(probe: unknown): CollabNegotiation {\n  if (probe === null || typeof probe !== \"object\") {\n    // A 200 that is not a JSON object: pre-negotiation server. Connect as before, offering nothing.\n    return { offer: [], refused: null };\n  }\n  const body = probe as { collab?: unknown; protocols?: unknown };\n  if (body.collab === false) {\n    return { offer: [], refused: \"This server has collaboration disabled.\" };\n  }\n  const { protocols } = body;\n  if (!Array.isArray(protocols) || protocols.length === 0) {\n    // A server that predates negotiation. It would echo nothing, so we must offer nothing.\n    return { offer: [], refused: null };\n  }\n  if (protocols.includes(COLLAB_SUBPROTOCOL)) {\n    return { offer: [COLLAB_SUBPROTOCOL], refused: null };\n  }\n  const theirs = protocols.filter((p) => typeof p === \"string\").join(\", \") || \"none\";\n  return {\n    offer: [],\n    refused: `This server speaks collab envelope ${theirs}; this editor speaks ${COLLAB_SUBPROTOCOL}.`,\n  };\n}\n\n/**\n * The subprotocols a client offered, from its `Sec-WebSocket-Protocol` request header.\n *\n * RFC 6455 §4.1 allows the field to be split across several header lines and comma-separated within\n * one; `Headers.get` already joins repeats with `, `, so one split covers both spellings.\n *\n * @param {string | null} header\n * @returns {string[]}\n */\nexport function offeredSubprotocols(header: string | null): string[] {\n  if (!header) {\n    return [];\n  }\n  return header\n    .split(\",\")\n    .map((token) => token.trim())\n    .filter((token) => token !== \"\");\n}\n\n/** What the server should do with an upgrade, given the client's offer. */\nexport interface SubprotocolAnswer {\n  /** The token to echo in the 101 response, or null to echo nothing. */\n  echo: string | null;\n  /** Non-null when the handshake must be refused instead of upgraded. */\n  reject: string | null;\n}\n\n/**\n * Choose the subprotocol to echo (RFC 6455 §4.2.2 step 4).\n *\n * Three cases, and the middle one is the one that is easy to get wrong:\n *\n * - **No offer** — an older client. Upgrade and echo nothing; it is not expecting an echo, and\n *   refusing it would break every Studio built before this shipped.\n * - **An offer we speak** — echo exactly that token. Echoing a token the client did not offer is\n *   itself a protocol violation, so the echo is always a member of the offer.\n * - **An offer we do not speak** — refuse. This is the whole point: two peers whose envelopes\n *   disagree about merge granularity (see `collab.md` §3.1) must not end up in one room, and a\n *   refused handshake is a far better outcome than a divergent-history merge.\n *\n * @param {string[]} offered\n * @returns {SubprotocolAnswer}\n */\nexport function selectSubprotocol(offered: string[]): SubprotocolAnswer {\n  if (offered.length === 0) {\n    return { echo: null, reject: null };\n  }\n  if (offered.includes(COLLAB_SUBPROTOCOL)) {\n    return { echo: COLLAB_SUBPROTOCOL, reject: null };\n  }\n  return {\n    echo: null,\n    reject: `No supported collab subprotocol offered (this server speaks ${COLLAB_SUBPROTOCOL}).`,\n  };\n}\n"
+  ],
+  "mappings": ";AA4BO,IAAM,qBAAqB;AAwB3B,SAAS,eAAe,CAAC,OAAmC;AAAA,EACjE,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;AAAA,IAE/C,OAAO,EAAE,OAAO,CAAC,GAAG,SAAS,KAAK;AAAA,EACpC;AAAA,EACA,MAAM,OAAO;AAAA,EACb,IAAI,KAAK,WAAW,OAAO;AAAA,IACzB,OAAO,EAAE,OAAO,CAAC,GAAG,SAAS,0CAA0C;AAAA,EACzE;AAAA,EACA,QAAQ,cAAc;AAAA,EACtB,IAAI,CAAC,MAAM,QAAQ,SAAS,KAAK,UAAU,WAAW,GAAG;AAAA,IAEvD,OAAO,EAAE,OAAO,CAAC,GAAG,SAAS,KAAK;AAAA,EACpC;AAAA,EACA,IAAI,UAAU,SAAS,kBAAkB,GAAG;AAAA,IAC1C,OAAO,EAAE,OAAO,CAAC,kBAAkB,GAAG,SAAS,KAAK;AAAA,EACtD;AAAA,EACA,MAAM,SAAS,UAAU,OAAO,CAAC,MAAM,OAAO,MAAM,QAAQ,EAAE,KAAK,IAAI,KAAK;AAAA,EAC5E,OAAO;AAAA,IACL,OAAO,CAAC;AAAA,IACR,SAAS,sCAAsC,8BAA8B;AAAA,EAC/E;AAAA;",
+  "debugId": "0E14F1DBFFC9648B64756E2164756E21",
+  "names": []
+}

package/dist/chunks/studio-dzcyvvvz.js

@@ -0,0 +1,166 @@
+import {
+  rectOf
+} from "./studio-v96qfnww.js";
+
+// src/ui/virtual-window.ts
+var DEFAULT_OVERSCAN_ROWS = 3;
+function clamp(value, low, high) {
+  return Math.min(high, Math.max(low, value));
+}
+function computeWindow(spec) {
+  const count = Math.max(0, Math.trunc(spec.count));
+  const columns = Math.max(1, Math.trunc(spec.columns ?? 1));
+  const totalRows = Math.ceil(count / columns);
+  if (!(spec.rowHeight > 0) || !(spec.viewportHeight > 0)) {
+    return { end: count, padBottom: 0, padTop: 0, start: 0, totalRows };
+  }
+  const overscan = Math.max(0, Math.trunc(spec.overscanRows ?? DEFAULT_OVERSCAN_ROWS));
+  const scrollTop = Math.max(0, spec.scrollTop);
+  const firstVisibleRow = Math.floor(scrollTop / spec.rowHeight);
+  const visibleRows = Math.ceil(spec.viewportHeight / spec.rowHeight) + 1;
+  const startRow = clamp(firstVisibleRow - overscan, 0, totalRows);
+  const endRow = clamp(firstVisibleRow + visibleRows + overscan, startRow, totalRows);
+  return {
+    end: Math.min(count, endRow * columns),
+    padBottom: (totalRows - endRow) * spec.rowHeight,
+    padTop: startRow * spec.rowHeight,
+    start: Math.min(count, startRow * columns),
+    totalRows
+  };
+}
+function sameWindow(a, b) {
+  return a.start === b.start && a.end === b.end && a.totalRows === b.totalRows;
+}
+function createVirtualWindow(options) {
+  const { scroller, list, count, rowHeight, columns, onChange, overscanRows } = options;
+  let current = { end: 0, padBottom: 0, padTop: 0, start: 0, totalRows: 0 };
+  let destroyed = false;
+  function measure() {
+    if (destroyed) {
+      return;
+    }
+    const next = computeWindow({
+      columns: columns?.() ?? 1,
+      count: count(),
+      overscanRows: overscanRows ?? DEFAULT_OVERSCAN_ROWS,
+      rowHeight: rowHeight(),
+      scrollTop: list ? listScrollTop(scroller, list) : scroller.scrollTop,
+      viewportHeight: scroller.clientHeight
+    });
+    const changed = !sameWindow(current, next);
+    current = next;
+    if (changed) {
+      onChange(next);
+    }
+  }
+  scroller.addEventListener("scroll", measure, { passive: true });
+  let resizeObserver = null;
+  if (typeof ResizeObserver === "function") {
+    resizeObserver = new ResizeObserver(() => measure());
+    resizeObserver.observe(scroller);
+  }
+  measure();
+  return {
+    destroy() {
+      destroyed = true;
+      scroller.removeEventListener("scroll", measure);
+      resizeObserver?.disconnect();
+      resizeObserver = null;
+    },
+    measure,
+    range: () => current
+  };
+}
+function nearestScroller(el) {
+  for (let node = el;node; node = node.parentElement) {
+    if (node.scrollHeight <= node.clientHeight) {
+      continue;
+    }
+    const overflow = getComputedStyle(node).overflowY;
+    if (overflow === "auto" || overflow === "scroll" || overflow === "overlay") {
+      return node;
+    }
+  }
+  return null;
+}
+function listScrollTop(scroller, list) {
+  if (scroller === list) {
+    return Math.max(0, scroller.scrollTop);
+  }
+  return Math.max(0, rectOf(scroller).top - rectOf(list).top);
+}
+function listWindow(list, spec) {
+  const scroller = list?.isConnected === true ? nearestScroller(list) : null;
+  if (!scroller || !list) {
+    const count = Math.max(0, Math.trunc(spec.count));
+    return { end: count, padBottom: 0, padTop: 0, start: 0, totalRows: count };
+  }
+  return computeWindow({
+    columns: spec.columns ?? 1,
+    count: spec.count,
+    ...spec.overscanRows === undefined ? {} : { overscanRows: spec.overscanRows },
+    rowHeight: spec.rowHeight,
+    scrollTop: listScrollTop(scroller, list),
+    viewportHeight: scroller.clientHeight
+  });
+}
+function scrollTopToReveal(spec) {
+  const top = spec.listOffset + spec.index * spec.rowHeight;
+  const bottom = top + spec.rowHeight;
+  if (top < spec.scrollTop) {
+    return Math.max(0, top);
+  }
+  if (bottom > spec.scrollTop + spec.viewportHeight) {
+    return Math.max(0, bottom - spec.viewportHeight);
+  }
+  return null;
+}
+function revealListRow(list, index, rowHeight) {
+  const scroller = list?.isConnected === true ? nearestScroller(list) : null;
+  if (!scroller || !list || index < 0 || !(rowHeight > 0)) {
+    return false;
+  }
+  const { scrollTop } = scroller;
+  const next = scrollTopToReveal({
+    index,
+    listOffset: scrollTop - listScrollTop(scroller, list),
+    rowHeight,
+    scrollTop,
+    viewportHeight: scroller.clientHeight
+  });
+  if (next === null) {
+    return false;
+  }
+  scroller.scrollTop = next;
+  return true;
+}
+function measuredRowHeight(list, selector, declared) {
+  const row = list?.querySelector(selector);
+  return row && row.offsetHeight > 0 ? row.offsetHeight : declared;
+}
+function watchListWindow(previous, list, spec) {
+  const scroller = nearestScroller(list);
+  if (previous && previous.list === list && previous.scroller === scroller) {
+    return previous;
+  }
+  previous?.window.destroy();
+  if (!scroller) {
+    return null;
+  }
+  return {
+    list,
+    scroller,
+    window: createVirtualWindow({
+      count: spec.count,
+      list,
+      onChange: () => spec.onChange(),
+      rowHeight: spec.rowHeight,
+      scroller
+    })
+  };
+}
+
+export { computeWindow, listWindow, revealListRow, measuredRowHeight, watchListWindow };
+
+//# debugId=4C38350338F9781B64756E2164756E21
+//# sourceMappingURL=studio-dzcyvvvz.js.map

package/dist/chunks/studio-dzcyvvvz.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/ui/virtual-window.ts"],
+  "sourcesContent": [
+    "/**\n * Virtual-window.ts — the windowing primitive behind every long list in Studio.\n *\n * **Why this is the acceptance criterion and not a nicety.** The Manage view the Library replaces\n * rendered one card per file with no cap, and each Pages/Layouts/Components/Content card mounted a\n * REAL `@jxsuite/runtime` render of that document. Opening \"All\" on a 300-page project therefore\n * built 300 live documents, in one synchronous lit pass, and kept every one of them alive in an\n * unbounded `Map`. The window is what makes the cost proportional to the VIEWPORT instead of to the\n * project. The two trees pay a smaller version of the same bill — a 5 000-node page drew 5 000\n * rows, each an `sp-icon` custom element — and they now pay it through this file.\n *\n * **It lives in `ui/`, not in `browse/`.** P3 workstream 11 promised \"one virtual-list primitive\n * behind the Files tree and the Outline tree, reused by the Library grid\", and what shipped sat\n * inside the Library and was imported by the Library alone. A primitive two surfaces share cannot\n * live inside one of them: the next surface that needs it either reaches across a feature boundary\n * or writes a second copy, and a second copy is how \"the tree renders every row\" survived a phase\n * that had already solved it.\n *\n * The maths is deliberately a pure function ({@link computeWindow}) rather than a class: it is the\n * part that has to be right, it is the part the perf test measures, and it needs no DOM to state.\n * {@link createVirtualWindow} is the thin observer that feeds it scroll positions, and the\n * {@link nearestScroller} half below is the small amount of DOM a list that does NOT own its own\n * scrollbar needs — both trees scroll inside `#left-panel`, which also holds their toolbars.\n *\n * One primitive, three surfaces: the Library (Table rows, Cards, Media), the Files tree and the\n * Outline. The geometry never mentions what an item IS.\n */\n\n/// <reference lib=\"dom\" />\n\nimport { rectOf } from \"../utils/geometry\";\n\n/** The measurement a window is computed from. Everything is in CSS pixels. */\nexport interface WindowSpec {\n  /** How many items exist in total. */\n  count: number;\n  /** Height of one ROW. A grid row holds {@link WindowSpec.columns} items. */\n  rowHeight: number;\n  /** Items per row. 1 for a list. Clamped to at least 1. */\n  columns?: number;\n  /** The scroller's current `scrollTop`. */\n  scrollTop: number;\n  /** The scroller's visible height. */\n  viewportHeight: number;\n  /** Extra rows rendered above and below the viewport. Defaults to {@link DEFAULT_OVERSCAN_ROWS}. */\n  overscanRows?: number;\n}\n\n/**\n * Which items to render, and how much empty space to reserve either side of them.\n *\n * `padTop`/`padBottom` are spacer heights rather than absolute positioning, so a windowed list is\n * still an ordinary flow container: it wraps, it prints, and a focused control inside it scrolls\n * into view without anything computing coordinates.\n */\nexport interface WindowRange {\n  /** First item index, inclusive. */\n  start: number;\n  /** Last item index, EXCLUSIVE. */\n  end: number;\n  /** Pixels of spacer above the first rendered row. */\n  padTop: number;\n  /** Pixels of spacer below the last rendered row. */\n  padBottom: number;\n  /** Total rows the full list would occupy — what the scrollbar is sized from. */\n  totalRows: number;\n}\n\n/**\n * Rows kept beyond each edge of the viewport.\n *\n * Three, not zero: a window with no overscan repaints on every scroll frame and shows a blank strip\n * for one frame at speed. Three is the smallest value at which neither is observable at a normal\n * wheel velocity, and it is small enough that the LRU preview cap still dominates.\n */\nexport const DEFAULT_OVERSCAN_ROWS = 3;\n\n/** Clamp `value` into `[low, high]`. */\nfunction clamp(value: number, low: number, high: number): number {\n  return Math.min(high, Math.max(low, value));\n}\n\n/**\n * The visible window for a spec.\n *\n * Total-safe by construction: a zero or negative `rowHeight` (an unmeasured container, a display:\n * none pane) yields the whole list rather than an infinite loop or an empty render, because a\n * Library that renders nothing is indistinguishable from a Library that found nothing — the exact\n * confusion this phase exists to remove.\n */\nexport function computeWindow(spec: WindowSpec): WindowRange {\n  const count = Math.max(0, Math.trunc(spec.count));\n  const columns = Math.max(1, Math.trunc(spec.columns ?? 1));\n  const totalRows = Math.ceil(count / columns);\n\n  if (!(spec.rowHeight > 0) || !(spec.viewportHeight > 0)) {\n    return { end: count, padBottom: 0, padTop: 0, start: 0, totalRows };\n  }\n\n  const overscan = Math.max(0, Math.trunc(spec.overscanRows ?? DEFAULT_OVERSCAN_ROWS));\n  const scrollTop = Math.max(0, spec.scrollTop);\n  const firstVisibleRow = Math.floor(scrollTop / spec.rowHeight);\n  const visibleRows = Math.ceil(spec.viewportHeight / spec.rowHeight) + 1;\n\n  const startRow = clamp(firstVisibleRow - overscan, 0, totalRows);\n  const endRow = clamp(firstVisibleRow + visibleRows + overscan, startRow, totalRows);\n\n  return {\n    end: Math.min(count, endRow * columns),\n    padBottom: (totalRows - endRow) * spec.rowHeight,\n    padTop: startRow * spec.rowHeight,\n    start: Math.min(count, startRow * columns),\n    totalRows,\n  };\n}\n\n/** Two ranges are the same window — the guard that keeps scrolling from repainting every frame. */\nexport function sameWindow(a: WindowRange, b: WindowRange): boolean {\n  return a.start === b.start && a.end === b.end && a.totalRows === b.totalRows;\n}\n\n// ─── The observer ────────────────────────────────────────────────────────────\n\nexport interface VirtualWindow {\n  /** The current range. Read during render; never stale by more than one frame. */\n  range: () => WindowRange;\n  /** Re-measure and recompute (count changed, layout changed, container resized). */\n  measure: () => void;\n  /** Stop listening. Idempotent. */\n  destroy: () => void;\n}\n\nexport interface VirtualWindowOptions {\n  /** The element that scrolls. */\n  scroller: HTMLElement;\n  /**\n   * The list inside `scroller`, when the scroller carries more than the list.\n   *\n   * Both trees scroll inside `#left-panel`, which also holds a project header, a toolbar and — for\n   * the Files tree — a search field. Their first row is therefore NOT at `scrollTop` 0, and a\n   * window computed from the scroller's own `scrollTop` would be that header's height out from the\n   * first scroll onwards. Omit it when the list IS the scroller (the Library's pane).\n   */\n  list?: HTMLElement;\n  /** Item count right now — read on every measure, so it may change without re-creating. */\n  count: () => number;\n  /** Row height right now. */\n  rowHeight: () => number;\n  /** Items per row right now. */\n  columns?: () => number;\n  /** Called only when the window actually CHANGED. */\n  onChange: (range: WindowRange) => void;\n  overscanRows?: number;\n}\n\n/**\n * Watch a scroller and report window changes.\n *\n * Scroll is listened to passively and answered synchronously: the range is cheap to compute and a\n * rAF hop would paint the spacer before the content one frame in three. `ResizeObserver` covers the\n * pane being resized; where the environment has none (happy-dom), `measure()` is the whole contract\n * and the caller drives it — which is also how the perf test drives it.\n */\nexport function createVirtualWindow(options: VirtualWindowOptions): VirtualWindow {\n  const { scroller, list, count, rowHeight, columns, onChange, overscanRows } = options;\n  let current: WindowRange = { end: 0, padBottom: 0, padTop: 0, start: 0, totalRows: 0 };\n  let destroyed = false;\n\n  function measure() {\n    if (destroyed) {\n      return;\n    }\n    const next = computeWindow({\n      columns: columns?.() ?? 1,\n      count: count(),\n      overscanRows: overscanRows ?? DEFAULT_OVERSCAN_ROWS,\n      rowHeight: rowHeight(),\n      scrollTop: list ? listScrollTop(scroller, list) : scroller.scrollTop,\n      viewportHeight: scroller.clientHeight,\n    });\n    const changed = !sameWindow(current, next);\n    current = next;\n    if (changed) {\n      onChange(next);\n    }\n  }\n\n  scroller.addEventListener(\"scroll\", measure, { passive: true });\n\n  let resizeObserver: ResizeObserver | null = null;\n  if (typeof ResizeObserver === \"function\") {\n    resizeObserver = new ResizeObserver(() => measure());\n    resizeObserver.observe(scroller);\n  }\n\n  measure();\n\n  return {\n    destroy() {\n      destroyed = true;\n      scroller.removeEventListener(\"scroll\", measure);\n      resizeObserver?.disconnect();\n      resizeObserver = null;\n    },\n    measure,\n    range: () => current,\n  };\n}\n\n// ─── A list that does not own its scrollbar ──────────────────────────────────\n\n/**\n * The element that scrolls `el`, or null when nothing does.\n *\n * TWO conditions, and the second is the one that makes this honest. An element is the scroller only\n * if it both declares a scrolling overflow AND currently has something to scroll. `.file-tree`\n * declares `overflow-y: auto` (styles/panels.css) but is never given a height, so it grows with its\n * content and never scrolls — treating it as the scroller would read its full content height as the\n * VIEWPORT height and window nothing at all, silently. The `scrollHeight > clientHeight` test walks\n * past it to `#left-panel`, which is where both trees actually scroll.\n *\n * The same test is why a list whose content fits is never windowed: there is nothing to scroll, so\n * there is nothing to save, and the whole list renders exactly as it always did.\n */\nexport function nearestScroller(el: HTMLElement | null): HTMLElement | null {\n  for (let node: HTMLElement | null = el; node; node = node.parentElement) {\n    // Cheap test first: happy-dom performs no layout, so this is 0 > 0 for every element and no\n    // Test ever pays for a `getComputedStyle` walk it cannot answer.\n    if (node.scrollHeight <= node.clientHeight) {\n      continue;\n    }\n    const overflow = getComputedStyle(node).overflowY;\n    if (overflow === \"auto\" || overflow === \"scroll\" || overflow === \"overlay\") {\n      return node;\n    }\n  }\n  return null;\n}\n\n/**\n * How far `list`'s first row has scrolled above the top of `scroller`'s viewport.\n *\n * Measured from the two rects rather than from `offsetTop`, because the chrome between them is not\n * a fixed height: the Files tree's toolbar and the project header are both conditional. When the\n * list IS the scroller there is no chrome and its own `scrollTop` is the answer.\n */\nexport function listScrollTop(scroller: HTMLElement, list: HTMLElement): number {\n  if (scroller === list) {\n    return Math.max(0, scroller.scrollTop);\n  }\n  return Math.max(0, rectOf(scroller).top - rectOf(list).top);\n}\n\n/**\n * The window for a list rendered inside whatever scrolls it — the trees' entry point.\n *\n * Answers \"the whole list\" for a list that has not been rendered yet, has been detached, or is not\n * inside anything that scrolls. That is not a fallback bolted on for tests: it is the FIRST paint\n * of every session (nothing can be measured before the rows exist), and it is every list short\n * enough to fit. Both must render everything, and both are what the trees did before they\n * windowed.\n */\nexport function listWindow(\n  list: HTMLElement | null,\n  spec: { count: number; rowHeight: number; columns?: number; overscanRows?: number },\n): WindowRange {\n  const scroller = list?.isConnected === true ? nearestScroller(list) : null;\n  if (!scroller || !list) {\n    const count = Math.max(0, Math.trunc(spec.count));\n    return { end: count, padBottom: 0, padTop: 0, start: 0, totalRows: count };\n  }\n  return computeWindow({\n    columns: spec.columns ?? 1,\n    count: spec.count,\n    ...(spec.overscanRows === undefined ? {} : { overscanRows: spec.overscanRows }),\n    rowHeight: spec.rowHeight,\n    scrollTop: listScrollTop(scroller, list),\n    viewportHeight: scroller.clientHeight,\n  });\n}\n\n/**\n * The `scrollTop` that brings row `index` into view, or null when it already is.\n *\n * `block: \"nearest\"` semantics, stated as arithmetic: a windowed list cannot delegate this to\n * `Element.scrollIntoView`, because the row it must reveal is precisely the one that has no\n * element. Pure, so the reveal rule is testable without a scroller.\n */\nexport function scrollTopToReveal(spec: {\n  index: number;\n  rowHeight: number;\n  /** Where the list's first row sits in the scroller's CONTENT, not its viewport. */\n  listOffset: number;\n  scrollTop: number;\n  viewportHeight: number;\n}): number | null {\n  const top = spec.listOffset + spec.index * spec.rowHeight;\n  const bottom = top + spec.rowHeight;\n  if (top < spec.scrollTop) {\n    return Math.max(0, top);\n  }\n  if (bottom > spec.scrollTop + spec.viewportHeight) {\n    return Math.max(0, bottom - spec.viewportHeight);\n  }\n  return null;\n}\n\n/**\n * Scroll `list` so that its row at `index` is inside the window on the next render.\n *\n * Returns whether anything moved. The re-render is deliberately NOT triggered here: assigning\n * `scrollTop` fires a `scroll` event, and the watch installed by {@link watchListWindow} is already\n * the one thing that decides when a scroll is worth a repaint. A caller that repainted as well\n * would paint twice for one keystroke.\n */\nexport function revealListRow(list: HTMLElement | null, index: number, rowHeight: number): boolean {\n  const scroller = list?.isConnected === true ? nearestScroller(list) : null;\n  if (!scroller || !list || index < 0 || !(rowHeight > 0)) {\n    return false;\n  }\n  const { scrollTop } = scroller;\n  const next = scrollTopToReveal({\n    index,\n    listOffset: scrollTop - listScrollTop(scroller, list),\n    rowHeight,\n    scrollTop,\n    viewportHeight: scroller.clientHeight,\n  });\n  if (next === null) {\n    return false;\n  }\n  scroller.scrollTop = next;\n  return true;\n}\n\n/**\n * The height one row actually has, measured, with the stylesheet's declared height as the answer\n * until a row exists to measure.\n *\n * Both are needed. The DECLARED height (`styles/panels.css` gives `.layer-row` and\n * `.file-tree-item` a `block-size`) is what lets the FIRST render window anything at all, before\n * any row has been laid out. The MEASUREMENT is what stops that constant becoming a lie the day\n * someone changes the row's padding, a user zooms, or a locale's font raises the line box: a window\n * computed from a stale height does not fail loudly, it drifts, and the list quietly ends a few\n * rows short of its own scrollbar.\n */\nexport function measuredRowHeight(\n  list: HTMLElement | null,\n  selector: string,\n  declared: number,\n): number {\n  const row = list?.querySelector<HTMLElement>(selector);\n  return row && row.offsetHeight > 0 ? row.offsetHeight : declared;\n}\n\n/** A live scroll watch over one list element. Held at module scope by the surface that renders it. */\nexport interface ListWindowWatch {\n  /** The list this watch is bound to. A different element means a different watch. */\n  list: HTMLElement;\n  /** The scroller it resolved to when it was bound. */\n  scroller: HTMLElement;\n  window: VirtualWindow;\n}\n\n/**\n * Bind — or keep — the scroll watch that repaints a windowed list.\n *\n * Called from the surface's `afterRender`, where the rows exist and the scroller can be resolved,\n * and handed back its own previous handle so re-binding is the exception rather than the rule: the\n * tree element survives every re-render (lit reuses it), so the steady state is \"same list, same\n * scroller, nothing to do\". A new element — the panel remounted, or moved dock — moves the\n * listener, and a list that no longer scrolls drops it.\n *\n * Returns the handle to keep, or null when nothing scrolls this list.\n */\nexport function watchListWindow(\n  previous: ListWindowWatch | null,\n  list: HTMLElement,\n  spec: { count: () => number; rowHeight: () => number; onChange: () => void },\n): ListWindowWatch | null {\n  const scroller = nearestScroller(list);\n  if (previous && previous.list === list && previous.scroller === scroller) {\n    return previous;\n  }\n  previous?.window.destroy();\n  if (!scroller) {\n    return null;\n  }\n  return {\n    list,\n    scroller,\n    window: createVirtualWindow({\n      count: spec.count,\n      list,\n      onChange: () => spec.onChange(),\n      rowHeight: spec.rowHeight,\n      scroller,\n    }),\n  };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "4C38350338F9781B64756E2164756E21",
+  "names": []
+}

package/dist/chunks/{studio-7kqe41sa.js → studio-evkr5d3b.js}

@@ -1,15 +1,20 @@
 import {
   focusableSelector
 } from "./studio-8q517dfr.js";
+import {
+  defineElement
+} from "./studio-18j3bmcz.js";
 import {
   SpectrumElement,
-  css,
   property,
   query
-} from "./studio-9qr6fq7p.js";
+} from "./studio-xm3dbxvn.js";
+import {
+  css
+} from "./studio-0rqqhrdy.js";
 import {
   ifDefined
-} from "./studio-cx91mnh8.js";
+} from "./studio-ckwz4d3x.js";
 import {
   html
 } from "./studio-5x5774ak.js";
@@ -235,7 +240,7 @@ class Tooltip extends SpectrumElement {
     `;
     if (this.selfManaged) {
       this.dependencyManager.add("sp-overlay");
-      import("./sp-overlay.dev-earn5as8.js");
+      import("./sp-overlay.dev-9ran0sfq.js");
       return html`
         <sp-overlay
           ?open=${this.open && !this.disabled && this.dependencyManager.loaded}
@@ -304,7 +309,10 @@ __decorateClass([
   property({ type: String })
 ], Tooltip.prototype, "variant", 1);
 
-export { DependencyManagerController, Tooltip };
+// ../../node_modules/@spectrum-web-components/tooltip/sp-tooltip.dev.js
+defineElement("sp-tooltip", Tooltip);
+
+export { DependencyManagerController };
 
-//# debugId=F962DCA5695ED76664756E2164756E21
-//# sourceMappingURL=studio-7kqe41sa.js.map
+//# debugId=B26C538C82CA430D64756E2164756E21
+//# sourceMappingURL=studio-evkr5d3b.js.map