@jxsuite/studio 2.0.1 → 2.1.0

package/dist/chunks/studio-xq0t7n5t.js

@@ -1,140 +0,0 @@
-import {
-  Directive,
-  PartType,
-  directive,
-  getCommittedValue,
-  insertPart,
-  removePart,
-  setChildPartValue,
-  setCommittedValue
-} from "./studio-4k0m4fmp.js";
-import {
-  noChange
-} from "./studio-5x5774ak.js";
-
-// ../../node_modules/lit-html/development/directives/repeat.js
-var generateMap = (list, start, end) => {
-  const map = new Map;
-  for (let i = start;i <= end; i++) {
-    map.set(list[i], i);
-  }
-  return map;
-};
-
-class RepeatDirective extends Directive {
-  constructor(partInfo) {
-    super(partInfo);
-    if (partInfo.type !== PartType.CHILD) {
-      throw new Error("repeat() can only be used in text expressions");
-    }
-  }
-  _getValuesAndKeys(items, keyFnOrTemplate, template) {
-    let keyFn;
-    if (template === undefined) {
-      template = keyFnOrTemplate;
-    } else if (keyFnOrTemplate !== undefined) {
-      keyFn = keyFnOrTemplate;
-    }
-    const keys = [];
-    const values = [];
-    let index = 0;
-    for (const item of items) {
-      keys[index] = keyFn ? keyFn(item, index) : index;
-      values[index] = template(item, index);
-      index++;
-    }
-    return {
-      values,
-      keys
-    };
-  }
-  render(items, keyFnOrTemplate, template) {
-    return this._getValuesAndKeys(items, keyFnOrTemplate, template).values;
-  }
-  update(containerPart, [items, keyFnOrTemplate, template]) {
-    const oldParts = getCommittedValue(containerPart);
-    const { values: newValues, keys: newKeys } = this._getValuesAndKeys(items, keyFnOrTemplate, template);
-    if (!Array.isArray(oldParts)) {
-      this._itemKeys = newKeys;
-      return newValues;
-    }
-    const oldKeys = this._itemKeys ??= [];
-    const newParts = [];
-    let newKeyToIndexMap;
-    let oldKeyToIndexMap;
-    let oldHead = 0;
-    let oldTail = oldParts.length - 1;
-    let newHead = 0;
-    let newTail = newValues.length - 1;
-    while (oldHead <= oldTail && newHead <= newTail) {
-      if (oldParts[oldHead] === null) {
-        oldHead++;
-      } else if (oldParts[oldTail] === null) {
-        oldTail--;
-      } else if (oldKeys[oldHead] === newKeys[newHead]) {
-        newParts[newHead] = setChildPartValue(oldParts[oldHead], newValues[newHead]);
-        oldHead++;
-        newHead++;
-      } else if (oldKeys[oldTail] === newKeys[newTail]) {
-        newParts[newTail] = setChildPartValue(oldParts[oldTail], newValues[newTail]);
-        oldTail--;
-        newTail--;
-      } else if (oldKeys[oldHead] === newKeys[newTail]) {
-        newParts[newTail] = setChildPartValue(oldParts[oldHead], newValues[newTail]);
-        insertPart(containerPart, newParts[newTail + 1], oldParts[oldHead]);
-        oldHead++;
-        newTail--;
-      } else if (oldKeys[oldTail] === newKeys[newHead]) {
-        newParts[newHead] = setChildPartValue(oldParts[oldTail], newValues[newHead]);
-        insertPart(containerPart, oldParts[oldHead], oldParts[oldTail]);
-        oldTail--;
-        newHead++;
-      } else {
-        if (newKeyToIndexMap === undefined) {
-          newKeyToIndexMap = generateMap(newKeys, newHead, newTail);
-          oldKeyToIndexMap = generateMap(oldKeys, oldHead, oldTail);
-        }
-        if (!newKeyToIndexMap.has(oldKeys[oldHead])) {
-          removePart(oldParts[oldHead]);
-          oldHead++;
-        } else if (!newKeyToIndexMap.has(oldKeys[oldTail])) {
-          removePart(oldParts[oldTail]);
-          oldTail--;
-        } else {
-          const oldIndex = oldKeyToIndexMap.get(newKeys[newHead]);
-          const oldPart = oldIndex !== undefined ? oldParts[oldIndex] : null;
-          if (oldPart === null) {
-            const newPart = insertPart(containerPart, oldParts[oldHead]);
-            setChildPartValue(newPart, newValues[newHead]);
-            newParts[newHead] = newPart;
-          } else {
-            newParts[newHead] = setChildPartValue(oldPart, newValues[newHead]);
-            insertPart(containerPart, oldParts[oldHead], oldPart);
-            oldParts[oldIndex] = null;
-          }
-          newHead++;
-        }
-      }
-    }
-    while (newHead <= newTail) {
-      const newPart = insertPart(containerPart, newParts[newTail + 1]);
-      setChildPartValue(newPart, newValues[newHead]);
-      newParts[newHead++] = newPart;
-    }
-    while (oldHead <= oldTail) {
-      const oldPart = oldParts[oldHead++];
-      if (oldPart !== null) {
-        removePart(oldPart);
-      }
-    }
-    this._itemKeys = newKeys;
-    setCommittedValue(containerPart, newParts);
-    return noChange;
-  }
-}
-var repeat = directive(RepeatDirective);
-
-export { repeat };
-
-//# debugId=25916A2DD803B44964756E2164756E21
-//# sourceMappingURL=studio-xq0t7n5t.js.map

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

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../node_modules/lit-html/development/directives/repeat.js"],
-  "sourcesContent": [
-    "/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport { noChange } from '../lit-html.js';\nimport { directive, Directive, PartType } from '../directive.js';\nimport { insertPart, getCommittedValue, removePart, setCommittedValue, setChildPartValue, } from '../directive-helpers.js';\n// Helper for generating a map of array item to its index over a subset\n// of an array (used to lazily generate `newKeyToIndexMap` and\n// `oldKeyToIndexMap`)\nconst generateMap = (list, start, end) => {\n    const map = new Map();\n    for (let i = start; i <= end; i++) {\n        map.set(list[i], i);\n    }\n    return map;\n};\nclass RepeatDirective extends Directive {\n    constructor(partInfo) {\n        super(partInfo);\n        if (partInfo.type !== PartType.CHILD) {\n            throw new Error('repeat() can only be used in text expressions');\n        }\n    }\n    _getValuesAndKeys(items, keyFnOrTemplate, template) {\n        let keyFn;\n        if (template === undefined) {\n            template = keyFnOrTemplate;\n        }\n        else if (keyFnOrTemplate !== undefined) {\n            keyFn = keyFnOrTemplate;\n        }\n        const keys = [];\n        const values = [];\n        let index = 0;\n        for (const item of items) {\n            keys[index] = keyFn ? keyFn(item, index) : index;\n            values[index] = template(item, index);\n            index++;\n        }\n        return {\n            values,\n            keys,\n        };\n    }\n    render(items, keyFnOrTemplate, template) {\n        return this._getValuesAndKeys(items, keyFnOrTemplate, template).values;\n    }\n    update(containerPart, [items, keyFnOrTemplate, template]) {\n        // Old part & key lists are retrieved from the last update (which may\n        // be primed by hydration)\n        const oldParts = getCommittedValue(containerPart);\n        const { values: newValues, keys: newKeys } = this._getValuesAndKeys(items, keyFnOrTemplate, template);\n        // We check that oldParts, the committed value, is an Array as an\n        // indicator that the previous value came from a repeat() call. If\n        // oldParts is not an Array then this is the first render and we return\n        // an array for lit-html's array handling to render, and remember the\n        // keys.\n        if (!Array.isArray(oldParts)) {\n            this._itemKeys = newKeys;\n            return newValues;\n        }\n        // In SSR hydration it's possible for oldParts to be an array but for us\n        // to not have item keys because the update() hasn't run yet. We set the\n        // keys to an empty array. This will cause all oldKey/newKey comparisons\n        // to fail and execution to fall to the last nested brach below which\n        // reuses the oldPart.\n        const oldKeys = (this._itemKeys ??= []);\n        // New part list will be built up as we go (either reused from\n        // old parts or created for new keys in this update). This is\n        // saved in the above cache at the end of the update.\n        const newParts = [];\n        // Maps from key to index for current and previous update; these\n        // are generated lazily only when needed as a performance\n        // optimization, since they are only required for multiple\n        // non-contiguous changes in the list, which are less common.\n        let newKeyToIndexMap;\n        let oldKeyToIndexMap;\n        // Head and tail pointers to old parts and new values\n        let oldHead = 0;\n        let oldTail = oldParts.length - 1;\n        let newHead = 0;\n        let newTail = newValues.length - 1;\n        // Overview of O(n) reconciliation algorithm (general approach\n        // based on ideas found in ivi, vue, snabbdom, etc.):\n        //\n        // * We start with the list of old parts and new values (and\n        //   arrays of their respective keys), head/tail pointers into\n        //   each, and we build up the new list of parts by updating\n        //   (and when needed, moving) old parts or creating new ones.\n        //   The initial scenario might look like this (for brevity of\n        //   the diagrams, the numbers in the array reflect keys\n        //   associated with the old parts or new values, although keys\n        //   and parts/values are actually stored in parallel arrays\n        //   indexed using the same head/tail pointers):\n        //\n        //      oldHead v                 v oldTail\n        //   oldKeys:  [0, 1, 2, 3, 4, 5, 6]\n        //   newParts: [ ,  ,  ,  ,  ,  ,  ]\n        //   newKeys:  [0, 2, 1, 4, 3, 7, 6] <- reflects the user's new\n        //                                      item order\n        //      newHead ^                 ^ newTail\n        //\n        // * Iterate old & new lists from both sides, updating,\n        //   swapping, or removing parts at the head/tail locations\n        //   until neither head nor tail can move.\n        //\n        // * Example below: keys at head pointers match, so update old\n        //   part 0 in-place (no need to move it) and record part 0 in\n        //   the `newParts` list. The last thing we do is advance the\n        //   `oldHead` and `newHead` pointers (will be reflected in the\n        //   next diagram).\n        //\n        //      oldHead v                 v oldTail\n        //   oldKeys:  [0, 1, 2, 3, 4, 5, 6]\n        //   newParts: [0,  ,  ,  ,  ,  ,  ] <- heads matched: update 0\n        //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    and advance both oldHead\n        //                                      & newHead\n        //      newHead ^                 ^ newTail\n        //\n        // * Example below: head pointers don't match, but tail\n        //   pointers do, so update part 6 in place (no need to move\n        //   it), and record part 6 in the `newParts` list. Last,\n        //   advance the `oldTail` and `oldHead` pointers.\n        //\n        //         oldHead v              v oldTail\n        //   oldKeys:  [0, 1, 2, 3, 4, 5, 6]\n        //   newParts: [0,  ,  ,  ,  ,  , 6] <- tails matched: update 6\n        //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    and advance both oldTail\n        //                                      & newTail\n        //         newHead ^              ^ newTail\n        //\n        // * If neither head nor tail match; next check if one of the\n        //   old head/tail items was removed. We first need to generate\n        //   the reverse map of new keys to index (`newKeyToIndexMap`),\n        //   which is done once lazily as a performance optimization,\n        //   since we only hit this case if multiple non-contiguous\n        //   changes were made. Note that for contiguous removal\n        //   anywhere in the list, the head and tails would advance\n        //   from either end and pass each other before we get to this\n        //   case and removals would be handled in the final while loop\n        //   without needing to generate the map.\n        //\n        // * Example below: The key at `oldTail` was removed (no longer\n        //   in the `newKeyToIndexMap`), so remove that part from the\n        //   DOM and advance just the `oldTail` pointer.\n        //\n        //         oldHead v           v oldTail\n        //   oldKeys:  [0, 1, 2, 3, 4, 5, 6]\n        //   newParts: [0,  ,  ,  ,  ,  , 6] <- 5 not in new map: remove\n        //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    5 and advance oldTail\n        //         newHead ^           ^ newTail\n        //\n        // * Once head and tail cannot move, any mismatches are due to\n        //   either new or moved items; if a new key is in the previous\n        //   \"old key to old index\" map, move the old part to the new\n        //   location, otherwise create and insert a new part. Note\n        //   that when moving an old part we null its position in the\n        //   oldParts array if it lies between the head and tail so we\n        //   know to skip it when the pointers get there.\n        //\n        // * Example below: neither head nor tail match, and neither\n        //   were removed; so find the `newHead` key in the\n        //   `oldKeyToIndexMap`, and move that old part's DOM into the\n        //   next head position (before `oldParts[oldHead]`). Last,\n        //   null the part in the `oldPart` array since it was\n        //   somewhere in the remaining oldParts still to be scanned\n        //   (between the head and tail pointers) so that we know to\n        //   skip that old part on future iterations.\n        //\n        //         oldHead v        v oldTail\n        //   oldKeys:  [0, 1, -, 3, 4, 5, 6]\n        //   newParts: [0, 2,  ,  ,  ,  , 6] <- stuck: update & move 2\n        //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    into place and advance\n        //                                      newHead\n        //         newHead ^           ^ newTail\n        //\n        // * Note that for moves/insertions like the one above, a part\n        //   inserted at the head pointer is inserted before the\n        //   current `oldParts[oldHead]`, and a part inserted at the\n        //   tail pointer is inserted before `newParts[newTail+1]`. The\n        //   seeming asymmetry lies in the fact that new parts are\n        //   moved into place outside in, so to the right of the head\n        //   pointer are old parts, and to the right of the tail\n        //   pointer are new parts.\n        //\n        // * We always restart back from the top of the algorithm,\n        //   allowing matching and simple updates in place to\n        //   continue...\n        //\n        // * Example below: the head pointers once again match, so\n        //   simply update part 1 and record it in the `newParts`\n        //   array.  Last, advance both head pointers.\n        //\n        //         oldHead v        v oldTail\n        //   oldKeys:  [0, 1, -, 3, 4, 5, 6]\n        //   newParts: [0, 2, 1,  ,  ,  , 6] <- heads matched: update 1\n        //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    and advance both oldHead\n        //                                      & newHead\n        //            newHead ^        ^ newTail\n        //\n        // * As mentioned above, items that were moved as a result of\n        //   being stuck (the final else clause in the code below) are\n        //   marked with null, so we always advance old pointers over\n        //   these so we're comparing the next actual old value on\n        //   either end.\n        //\n        // * Example below: `oldHead` is null (already placed in\n        //   newParts), so advance `oldHead`.\n        //\n        //            oldHead v     v oldTail\n        //   oldKeys:  [0, 1, -, 3, 4, 5, 6] <- old head already used:\n        //   newParts: [0, 2, 1,  ,  ,  , 6]    advance oldHead\n        //   newKeys:  [0, 2, 1, 4, 3, 7, 6]\n        //               newHead ^     ^ newTail\n        //\n        // * Note it's not critical to mark old parts as null when they\n        //   are moved from head to tail or tail to head, since they\n        //   will be outside the pointer range and never visited again.\n        //\n        // * Example below: Here the old tail key matches the new head\n        //   key, so the part at the `oldTail` position and move its\n        //   DOM to the new head position (before `oldParts[oldHead]`).\n        //   Last, advance `oldTail` and `newHead` pointers.\n        //\n        //               oldHead v  v oldTail\n        //   oldKeys:  [0, 1, -, 3, 4, 5, 6]\n        //   newParts: [0, 2, 1, 4,  ,  , 6] <- old tail matches new\n        //   newKeys:  [0, 2, 1, 4, 3, 7, 6]   head: update & move 4,\n        //                                     advance oldTail & newHead\n        //               newHead ^     ^ newTail\n        //\n        // * Example below: Old and new head keys match, so update the\n        //   old head part in place, and advance the `oldHead` and\n        //   `newHead` pointers.\n        //\n        //               oldHead v oldTail\n        //   oldKeys:  [0, 1, -, 3, 4, 5, 6]\n        //   newParts: [0, 2, 1, 4, 3,   ,6] <- heads match: update 3\n        //   newKeys:  [0, 2, 1, 4, 3, 7, 6]    and advance oldHead &\n        //                                      newHead\n        //                  newHead ^  ^ newTail\n        //\n        // * Once the new or old pointers move past each other then all\n        //   we have left is additions (if old list exhausted) or\n        //   removals (if new list exhausted). Those are handled in the\n        //   final while loops at the end.\n        //\n        // * Example below: `oldHead` exceeded `oldTail`, so we're done\n        //   with the main loop.  Create the remaining part and insert\n        //   it at the new head position, and the update is complete.\n        //\n        //                   (oldHead > oldTail)\n        //   oldKeys:  [0, 1, -, 3, 4, 5, 6]\n        //   newParts: [0, 2, 1, 4, 3, 7 ,6] <- create and insert 7\n        //   newKeys:  [0, 2, 1, 4, 3, 7, 6]\n        //                     newHead ^ newTail\n        //\n        // * Note that the order of the if/else clauses is not\n        //   important to the algorithm, as long as the null checks\n        //   come first (to ensure we're always working on valid old\n        //   parts) and that the final else clause comes last (since\n        //   that's where the expensive moves occur). The order of\n        //   remaining clauses is just a simple guess at which cases\n        //   will be most common.\n        //\n        // * Note, we could calculate the longest\n        //   increasing subsequence (LIS) of old items in new position,\n        //   and only move those not in the LIS set. However that costs\n        //   O(nlogn) time and adds a bit more code, and only helps\n        //   make rare types of mutations require fewer moves. The\n        //   above handles removes, adds, reversal, swaps, and single\n        //   moves of contiguous items in linear time, in the minimum\n        //   number of moves. As the number of multiple moves where LIS\n        //   might help approaches a random shuffle, the LIS\n        //   optimization becomes less helpful, so it seems not worth\n        //   the code at this point. Could reconsider if a compelling\n        //   case arises.\n        while (oldHead <= oldTail && newHead <= newTail) {\n            if (oldParts[oldHead] === null) {\n                // `null` means old part at head has already been used\n                // below; skip\n                oldHead++;\n            }\n            else if (oldParts[oldTail] === null) {\n                // `null` means old part at tail has already been used\n                // below; skip\n                oldTail--;\n            }\n            else if (oldKeys[oldHead] === newKeys[newHead]) {\n                // Old head matches new head; update in place\n                newParts[newHead] = setChildPartValue(oldParts[oldHead], newValues[newHead]);\n                oldHead++;\n                newHead++;\n            }\n            else if (oldKeys[oldTail] === newKeys[newTail]) {\n                // Old tail matches new tail; update in place\n                newParts[newTail] = setChildPartValue(oldParts[oldTail], newValues[newTail]);\n                oldTail--;\n                newTail--;\n            }\n            else if (oldKeys[oldHead] === newKeys[newTail]) {\n                // Old head matches new tail; update and move to new tail\n                newParts[newTail] = setChildPartValue(oldParts[oldHead], newValues[newTail]);\n                insertPart(containerPart, newParts[newTail + 1], oldParts[oldHead]);\n                oldHead++;\n                newTail--;\n            }\n            else if (oldKeys[oldTail] === newKeys[newHead]) {\n                // Old tail matches new head; update and move to new head\n                newParts[newHead] = setChildPartValue(oldParts[oldTail], newValues[newHead]);\n                insertPart(containerPart, oldParts[oldHead], oldParts[oldTail]);\n                oldTail--;\n                newHead++;\n            }\n            else {\n                if (newKeyToIndexMap === undefined) {\n                    // Lazily generate key-to-index maps, used for removals &\n                    // moves below\n                    newKeyToIndexMap = generateMap(newKeys, newHead, newTail);\n                    oldKeyToIndexMap = generateMap(oldKeys, oldHead, oldTail);\n                }\n                if (!newKeyToIndexMap.has(oldKeys[oldHead])) {\n                    // Old head is no longer in new list; remove\n                    removePart(oldParts[oldHead]);\n                    oldHead++;\n                }\n                else if (!newKeyToIndexMap.has(oldKeys[oldTail])) {\n                    // Old tail is no longer in new list; remove\n                    removePart(oldParts[oldTail]);\n                    oldTail--;\n                }\n                else {\n                    // Any mismatches at this point are due to additions or\n                    // moves; see if we have an old part we can reuse and move\n                    // into place\n                    const oldIndex = oldKeyToIndexMap.get(newKeys[newHead]);\n                    const oldPart = oldIndex !== undefined ? oldParts[oldIndex] : null;\n                    if (oldPart === null) {\n                        // No old part for this value; create a new one and\n                        // insert it\n                        const newPart = insertPart(containerPart, oldParts[oldHead]);\n                        setChildPartValue(newPart, newValues[newHead]);\n                        newParts[newHead] = newPart;\n                    }\n                    else {\n                        // Reuse old part\n                        newParts[newHead] = setChildPartValue(oldPart, newValues[newHead]);\n                        insertPart(containerPart, oldParts[oldHead], oldPart);\n                        // This marks the old part as having been used, so that\n                        // it will be skipped in the first two checks above\n                        oldParts[oldIndex] = null;\n                    }\n                    newHead++;\n                }\n            }\n        }\n        // Add parts for any remaining new values\n        while (newHead <= newTail) {\n            // For all remaining additions, we insert before last new\n            // tail, since old pointers are no longer valid\n            const newPart = insertPart(containerPart, newParts[newTail + 1]);\n            setChildPartValue(newPart, newValues[newHead]);\n            newParts[newHead++] = newPart;\n        }\n        // Remove any remaining unused old parts\n        while (oldHead <= oldTail) {\n            const oldPart = oldParts[oldHead++];\n            if (oldPart !== null) {\n                removePart(oldPart);\n            }\n        }\n        // Save order of new parts for next round\n        this._itemKeys = newKeys;\n        // Directly set part value, bypassing it's dirty-checking\n        setCommittedValue(containerPart, newParts);\n        return noChange;\n    }\n}\n/**\n * A directive that repeats a series of values (usually `TemplateResults`)\n * generated from an iterable, and updates those items efficiently when the\n * iterable changes based on user-provided `keys` associated with each item.\n *\n * Note that if a `keyFn` is provided, strict key-to-DOM mapping is maintained,\n * meaning previous DOM for a given key is moved into the new position if\n * needed, and DOM will never be reused with values for different keys (new DOM\n * will always be created for new keys). This is generally the most efficient\n * way to use `repeat` since it performs minimum unnecessary work for insertions\n * and removals.\n *\n * The `keyFn` takes two parameters, the item and its index, and returns a unique key value.\n *\n * ```js\n * html`\n *   <ol>\n *     ${repeat(this.items, (item) => item.id, (item, index) => {\n *       return html`<li>${index}: ${item.name}</li>`;\n *     })}\n *   </ol>\n * `\n * ```\n *\n * **Important**: If providing a `keyFn`, keys *must* be unique for all items in a\n * given call to `repeat`. The behavior when two or more items have the same key\n * is undefined.\n *\n * If no `keyFn` is provided, this directive will perform similar to mapping\n * items to values, and DOM will be reused against potentially different items.\n */\nexport const repeat = directive(RepeatDirective);\n//# sourceMappingURL=repeat.js.map"
-  ],
-  "mappings": "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",
-  "debugId": "25916A2DD803B44964756E2164756E21",
-  "names": []
-}

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

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../collab/src/envelope.ts"],
-  "sourcesContent": [
-    "/**\n * The binary wire envelope every Jx collab provider speaks: the Cloudflare platform DO, the\n * devserver endpoint in the server package, and the browser client. One WebSocket per project\n * carries every open document, multiplexed by path:\n *\n *     frame          := varUint frameType, body\n *     0 DOC_SYNC     := varString path, varUint docEpoch, varUint8Array y-protocols sync body\n *     1 AWARENESS    := varUint8Array y-protocols awareness update (project-scoped)\n *     2 DOC_CLOSE    := varString path                (client → server unsubscribe)\n *     3 CONTROL      := varString json                (see ControlMessage)\n *\n * `docEpoch` is the server-owned lifetime counter of a document's Y history. Out-of-band content\n * replacement (git discard/pull/rename, non-collab writes) bumps it; frames carrying a stale epoch\n * are dropped and answered with a `doc-reset` control message, upon which the client destroys its\n * Y.Doc and re-opens. The invariant \"Y history is never deleted or replaced without an epoch bump\"\n * is what prevents divergent-history duplicate-content merges.\n */\n\nimport * as decoding from \"lib0/decoding\";\nimport * as encoding from \"lib0/encoding\";\n\nexport const FRAME_DOC_SYNC = 0;\nexport const FRAME_AWARENESS = 1;\nexport const FRAME_DOC_CLOSE = 2;\nexport const FRAME_CONTROL = 3;\n\nexport type CollabPermission = \"admin\" | \"write\" | \"read\";\n\n/** JSON payloads of CONTROL frames. */\nexport type ControlMessage =\n  /** Server → client on accept: the socket's identity and effective permission. */\n  | {\n      type: \"hello\";\n      login: string;\n      name?: string;\n      avatarUrl?: string;\n      color: string;\n      permission: CollabPermission;\n    }\n  /** Client → server: subscribe to a document (the client's Y.Doc must start EMPTY). */\n  | { type: \"open\"; path: string }\n  /** Server → client: the room is ready at this epoch; sync follows. */\n  | { type: \"opened\"; path: string; epoch: number }\n  /** Server → client: the doc's history was replaced; destroy the local Y.Doc and re-open. */\n  | { type: \"doc-reset\"; path: string; epoch: number }\n  /** Client → server: persist this doc to durable storage now (Cmd+S). */\n  | { type: \"flush\"; path: string }\n  /** Server → client: the flush landed. */\n  | { type: \"flush-ack\"; path: string }\n  /**\n   * Server → client: the room's unsaved-since-last-persist state changed (drives the Save\n   * affordance). Room-level and authoritative: any peer's edit dirties the room for everyone; a\n   * persist clears it for everyone. Sent to a newly-subscribing connection during the open\n   * handshake so it learns the current state.\n   */\n  | { type: \"doc-dirty\"; path: string; dirty: boolean }\n  /**\n   * Server → client: a request was refused (codes: read-only, content-not-loaded, too-large,\n   * rate-limited, binary-file, unknown-frame).\n   */\n  | { type: \"error\"; path?: string; code: string; message: string };\n\nexport type CollabFrame =\n  | { type: \"doc-sync\"; path: string; epoch: number; body: Uint8Array }\n  | { type: \"awareness\"; body: Uint8Array }\n  | { type: \"doc-close\"; path: string }\n  | { type: \"control\"; message: ControlMessage };\n\nexport class EnvelopeError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"EnvelopeError\";\n  }\n}\n\nexport function encodeFrame(frame: CollabFrame): Uint8Array {\n  const encoder = encoding.createEncoder();\n  switch (frame.type) {\n    case \"doc-sync\": {\n      encoding.writeVarUint(encoder, FRAME_DOC_SYNC);\n      encoding.writeVarString(encoder, frame.path);\n      encoding.writeVarUint(encoder, frame.epoch);\n      encoding.writeVarUint8Array(encoder, frame.body);\n      break;\n    }\n    case \"awareness\": {\n      encoding.writeVarUint(encoder, FRAME_AWARENESS);\n      encoding.writeVarUint8Array(encoder, frame.body);\n      break;\n    }\n    case \"doc-close\": {\n      encoding.writeVarUint(encoder, FRAME_DOC_CLOSE);\n      encoding.writeVarString(encoder, frame.path);\n      break;\n    }\n    case \"control\": {\n      encoding.writeVarUint(encoder, FRAME_CONTROL);\n      encoding.writeVarString(encoder, JSON.stringify(frame.message));\n      break;\n    }\n    default: {\n      throw new EnvelopeError(`unknown-frame:${(frame as CollabFrame).type}`);\n    }\n  }\n  return encoding.toUint8Array(encoder);\n}\n\nexport function decodeFrame(data: Uint8Array): CollabFrame {\n  try {\n    const decoder = decoding.createDecoder(data);\n    const frameType = decoding.readVarUint(decoder);\n    switch (frameType) {\n      case FRAME_DOC_SYNC: {\n        const path = decoding.readVarString(decoder);\n        const epoch = decoding.readVarUint(decoder);\n        const body = decoding.readVarUint8Array(decoder);\n        return { body, epoch, path, type: \"doc-sync\" };\n      }\n      case FRAME_AWARENESS: {\n        return { body: decoding.readVarUint8Array(decoder), type: \"awareness\" };\n      }\n      case FRAME_DOC_CLOSE: {\n        return { path: decoding.readVarString(decoder), type: \"doc-close\" };\n      }\n      case FRAME_CONTROL: {\n        const message = JSON.parse(decoding.readVarString(decoder)) as ControlMessage;\n        if (typeof message !== \"object\" || typeof message.type !== \"string\") {\n          throw new EnvelopeError(\"malformed-control\");\n        }\n        return { message, type: \"control\" };\n      }\n      default: {\n        throw new EnvelopeError(`unknown-frame-type:${frameType}`);\n      }\n    }\n  } catch (error) {\n    if (error instanceof EnvelopeError) {\n      throw error;\n    }\n    throw new EnvelopeError(\n      `malformed-frame: ${error instanceof Error ? error.message : String(error)}`,\n    );\n  }\n}\n"
-  ],
-  "mappings": ";;;;;;;;;;;;;AAqBO,IAAM,iBAAiB;AACvB,IAAM,kBAAkB;AACxB,IAAM,kBAAkB;AACxB,IAAM,gBAAgB;AAAA;AA4CtB,MAAM,sBAAsB,MAAM;AAAA,EACvC,WAAW,CAAC,SAAiB;AAAA,IAC3B,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA;AAEhB;AAEO,SAAS,WAAW,CAAC,OAAgC;AAAA,EAC1D,MAAM,UAAmB,cAAc;AAAA,EACvC,QAAQ,MAAM;AAAA,SACP,YAAY;AAAA,MACN,aAAa,SAAS,cAAc;AAAA,MACpC,eAAe,SAAS,MAAM,IAAI;AAAA,MAClC,aAAa,SAAS,MAAM,KAAK;AAAA,MACjC,mBAAmB,SAAS,MAAM,IAAI;AAAA,MAC/C;AAAA,IACF;AAAA,SACK,aAAa;AAAA,MACP,aAAa,SAAS,eAAe;AAAA,MACrC,mBAAmB,SAAS,MAAM,IAAI;AAAA,MAC/C;AAAA,IACF;AAAA,SACK,aAAa;AAAA,MACP,aAAa,SAAS,eAAe;AAAA,MACrC,eAAe,SAAS,MAAM,IAAI;AAAA,MAC3C;AAAA,IACF;AAAA,SACK,WAAW;AAAA,MACL,aAAa,SAAS,aAAa;AAAA,MACnC,eAAe,SAAS,KAAK,UAAU,MAAM,OAAO,CAAC;AAAA,MAC9D;AAAA,IACF;AAAA,aACS;AAAA,MACP,MAAM,IAAI,cAAc,iBAAkB,MAAsB,MAAM;AAAA,IACxE;AAAA;AAAA,EAEF,OAAgB,aAAa,OAAO;AAAA;AAG/B,SAAS,WAAW,CAAC,MAA+B;AAAA,EACzD,IAAI;AAAA,IACF,MAAM,UAAmB,cAAc,IAAI;AAAA,IAC3C,MAAM,YAAqB,YAAY,OAAO;AAAA,IAC9C,QAAQ;AAAA,WACD,gBAAgB;AAAA,QACnB,MAAM,OAAgB,cAAc,OAAO;AAAA,QAC3C,MAAM,QAAiB,YAAY,OAAO;AAAA,QAC1C,MAAM,OAAgB,kBAAkB,OAAO;AAAA,QAC/C,OAAO,EAAE,MAAM,OAAO,MAAM,MAAM,WAAW;AAAA,MAC/C;AAAA,WACK,iBAAiB;AAAA,QACpB,OAAO,EAAE,MAAe,kBAAkB,OAAO,GAAG,MAAM,YAAY;AAAA,MACxE;AAAA,WACK,iBAAiB;AAAA,QACpB,OAAO,EAAE,MAAe,cAAc,OAAO,GAAG,MAAM,YAAY;AAAA,MACpE;AAAA,WACK,eAAe;AAAA,QAClB,MAAM,UAAU,KAAK,MAAe,cAAc,OAAO,CAAC;AAAA,QAC1D,IAAI,OAAO,YAAY,YAAY,OAAO,QAAQ,SAAS,UAAU;AAAA,UACnE,MAAM,IAAI,cAAc,mBAAmB;AAAA,QAC7C;AAAA,QACA,OAAO,EAAE,SAAS,MAAM,UAAU;AAAA,MACpC;AAAA,eACS;AAAA,QACP,MAAM,IAAI,cAAc,sBAAsB,WAAW;AAAA,MAC3D;AAAA;AAAA,IAEF,OAAO,OAAO;AAAA,IACd,IAAI,iBAAiB,eAAe;AAAA,MAClC,MAAM;AAAA,IACR;AAAA,IACA,MAAM,IAAI,cACR,oBAAoB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GAC3E;AAAA;AAAA;",
-  "debugId": "DAAAC2821D4C97A164756E2164756E21",
-  "names": []
-}

package/dist/chunks/studio-yfcstdzy.js

@@ -1,399 +0,0 @@
-import {
-  classMap,
-  ifDefined,
-  styleMap
-} from "./studio-cx91mnh8.js";
-import {
-  live
-} from "./studio-nqw433kv.js";
-import {
-  isRef
-} from "./studio-sjh1wt1a.js";
-import {
-  html,
-  nothing
-} from "./studio-5x5774ak.js";
-
-// src/ui/field-row.ts
-function renderFieldRow({
-  prop,
-  label,
-  hasValue,
-  onClear,
-  widget,
-  labelExtra,
-  span,
-  warning
-}) {
-  return html`
-    <div
-      class=${classMap({ "style-row": true, "style-row--warning": Boolean(warning) })}
-      data-prop=${prop}
-      style=${span === 2 ? "grid-column: 1 / -1" : ""}
-    >
-      <div class="style-row-label">
-        ${hasValue && onClear ? html`<span
-                class="set-dot"
-                title="Clear ${prop}"
-                @click=${(e) => {
-    e.stopPropagation();
-    onClear();
-  }}
-              ></span>` : nothing}
-        <sp-field-label size="s" title=${prop}>${label}</sp-field-label>
-        ${labelExtra ?? nothing}
-      </div>
-      ${widget}
-    </div>
-  `;
-}
-
-// src/ui/schema-form.ts
-var controlRegistry = new Map;
-function registerFormControl(name, control) {
-  controlRegistry.set(name, control);
-}
-var NULL_CONTEXT = {
-  resolvePointer: () => {}
-};
-function resolveFormEnum(enumDef, ctx, scope) {
-  if (Array.isArray(enumDef)) {
-    return enumDef;
-  }
-  let pointer;
-  if (enumDef && typeof enumDef === "object") {
-    const ref = enumDef.$ref;
-    if (typeof ref === "string") {
-      pointer = ref;
-    }
-  } else if (typeof enumDef === "string") {
-    pointer = enumDef;
-  }
-  if (pointer === undefined || !ctx) {
-    return;
-  }
-  const resolved = ctx.resolvePointer(pointer, scope);
-  if (Array.isArray(resolved)) {
-    return resolved.map(String);
-  }
-  if (resolved && typeof resolved === "object") {
-    return Object.keys(resolved);
-  }
-  return;
-}
-function parseNumericField(raw, integer) {
-  if (raw.trim() === "") {
-    return Number.NaN;
-  }
-  return integer ? Math.trunc(Number(raw)) : Number(raw);
-}
-function refTextField(key, refVal, onChange) {
-  return html`<sp-textfield
-    size="s"
-    label=${key}
-    placeholder=${key}
-    .value=${live(refVal)}
-    @change=${(e) => {
-    const v = e.target.value.trim();
-    onChange(v ? { $ref: v } : undefined);
-  }}
-  ></sp-textfield>`;
-}
-function renderInlineField(key, schema, value, onChange, ctx, scope) {
-  if (isRef(value)) {
-    return refTextField(key, value.$ref, onChange);
-  }
-  const enumValues = resolveFormEnum(schema.enum, ctx, scope);
-  if (enumValues) {
-    return html`<sp-picker
-      size="s"
-      label=${key}
-      value=${value !== undefined ? String(value) : "__none__"}
-      @change=${(e) => onChange(e.target.value === "__none__" ? undefined : e.target.value)}
-    >
-      <sp-menu-item value="__none__">—</sp-menu-item>
-      ${enumValues.map((v) => html`<sp-menu-item value=${v}>${v}</sp-menu-item>`)}
-    </sp-picker>`;
-  }
-  if (schema.type === "boolean") {
-    return html`<sp-switch
-      size="s"
-      ?checked=${Boolean(value)}
-      @change=${(e) => onChange(e.target.checked)}
-      >${key}</sp-switch
-    >`;
-  }
-  if (schema.type === "integer" || schema.type === "number") {
-    return html`<sp-number-field
-      size="s"
-      label=${key}
-      .value=${value !== undefined ? value : nothing}
-      step=${schema.type === "integer" ? "1" : nothing}
-      @change=${(e) => {
-      const parsed = parseNumericField(e.target.value, schema.type === "integer");
-      onChange(Number.isNaN(parsed) ? undefined : parsed);
-    }}
-    ></sp-number-field>`;
-  }
-  return html`<sp-textfield
-    size="s"
-    label=${key}
-    placeholder=${key}
-    .value=${value ?? ""}
-    @input=${(e) => onChange(e.target.value || undefined)}
-  ></sp-textfield>`;
-}
-function renderJsonTextField(currentValue, ps, commit) {
-  let debounce;
-  return html`<sp-textfield
-    multiline
-    size="s"
-    style="min-height:40px"
-    .value=${currentValue !== undefined ? JSON.stringify(currentValue, null, 2) : ""}
-    placeholder=${ps.default !== undefined ? JSON.stringify(ps.default) : nothing}
-    @input=${(e) => {
-    clearTimeout(debounce);
-    debounce = setTimeout(() => {
-      try {
-        commit(JSON.parse(e.target.value));
-      } catch {}
-    }, 500);
-  }}
-  ></sp-textfield>`;
-}
-function renderPropertyControl(prop, ps, value, required, opts, ctx) {
-  const currentValue = value[prop];
-  const commit = (next) => opts.onChange({ [prop]: next });
-  const controlArgs = {
-    ctx,
-    key: prop,
-    onChange: commit,
-    rerender: opts.rerender,
-    schema: ps,
-    value: currentValue
-  };
-  const overrideName = opts.ui?.[prop]?.control;
-  if (overrideName) {
-    const custom = controlRegistry.get(overrideName);
-    if (custom) {
-      return custom(controlArgs);
-    }
-  }
-  if (isRef(currentValue) && ps.format !== "json-schema" && ps.type !== "object" && ps.type !== "array") {
-    const binding = controlRegistry.get("binding");
-    if (binding) {
-      return binding(controlArgs);
-    }
-    return refTextField(prop, currentValue.$ref, commit);
-  }
-  const enumValues = resolveFormEnum(opts.ui?.[prop]?.enum ?? ps.enum, ctx, value);
-  if (enumValues) {
-    return html`
-      <sp-picker
-        size="s"
-        value=${currentValue !== undefined ? String(currentValue) : ps.default !== undefined ? String(ps.default) : "__none__"}
-        @change=${(e) => commit(e.target.value === "__none__" ? undefined : e.target.value)}
-      >
-        ${!required.has(prop) ? html`<sp-menu-item value="__none__">—</sp-menu-item>` : nothing}
-        ${enumValues.map((val) => html`<sp-menu-item value=${val}>${val}</sp-menu-item>`)}
-      </sp-picker>
-    `;
-  }
-  if (ps.type === "boolean") {
-    return html`<sp-checkbox
-      ?checked=${currentValue ?? ps.default ?? false}
-      @change=${(e) => commit(e.target.checked)}
-    ></sp-checkbox>`;
-  }
-  if (ps.type === "integer" || ps.type === "number") {
-    let debounce2;
-    return html`<sp-number-field
-      size="s"
-      min=${ifDefined(ps.minimum)}
-      max=${ifDefined(ps.maximum)}
-      step=${ps.type === "integer" ? "1" : nothing}
-      .value=${currentValue !== undefined ? currentValue : nothing}
-      placeholder=${ps.default != null ? String(ps.default) : nothing}
-      @change=${(e) => {
-      clearTimeout(debounce2);
-      debounce2 = setTimeout(() => {
-        const parsed = parseNumericField(e.target.value, ps.type === "integer");
-        commit(Number.isNaN(parsed) ? undefined : parsed);
-      }, 400);
-    }}
-    ></sp-number-field>`;
-  }
-  if (ps.format === "json-schema") {
-    const hasValue = currentValue && typeof currentValue === "object" && Object.keys(currentValue).length > 0;
-    const cv = currentValue;
-    const isSchemaRef = hasValue && cv.$ref;
-    let debounce2;
-    return html`
-      <div class="schema-param-editor">
-        ${hasValue && !isSchemaRef && cv.properties ? html`
-                <div style="display:flex;flex-wrap:wrap;gap:3px;margin-bottom:4px">
-                  ${Object.entries(cv.properties).map(([k, v]) => html`
-                      <span
-                        style="background:var(--bg);padding:1px 6px;border-radius:var(--radius);font-size:10px;color:var(--fg-dim)"
-                        >${k}: ${v.type ?? "any"}</span
-                      >
-                    `)}
-                </div>
-              ` : nothing}
-        <sp-textfield
-          multiline
-          size="s"
-          style=${styleMap({
-      fontFamily: "monospace",
-      fontSize: "11px",
-      minHeight: hasValue ? "80px" : "40px"
-    })}
-          .value=${currentValue !== undefined ? JSON.stringify(currentValue, null, 2) : ""}
-          placeholder=${ps.description ?? "JSON Schema defining the data shape…"}
-          @input=${(e) => {
-      clearTimeout(debounce2);
-      debounce2 = setTimeout(() => {
-        try {
-          commit(JSON.parse(e.target.value));
-        } catch {}
-      }, 500);
-    }}
-        ></sp-textfield>
-      </div>
-    `;
-  }
-  if (ps.type === "array" && ps.items?.type === "object" && ps.items?.properties) {
-    const rows = Array.isArray(currentValue) ? currentValue : [];
-    const itemProps = ps.items.properties;
-    return html`
-      <div class="array-object-field">
-        ${rows.map((row, idx) => html`
-            <div
-              class="array-object-row"
-              style="display:flex;gap:4px;align-items:center;margin-bottom:4px"
-            >
-              ${Object.entries(itemProps).map(([propKey, propSchema]) => renderInlineField(propKey, propSchema, row[propKey], (val) => {
-      const updated = [...rows];
-      updated[idx] = { ...updated[idx], [propKey]: val };
-      commit(updated);
-    }, ctx, value))}
-              <sp-action-button
-                quiet
-                size="s"
-                @click=${() => {
-      const updated = rows.filter((_, i) => i !== idx);
-      commit(updated.length > 0 ? updated : undefined);
-      opts.rerender?.();
-    }}
-              >
-                <sp-icon-delete slot="icon"></sp-icon-delete>
-              </sp-action-button>
-            </div>
-          `)}
-        <sp-action-button
-          quiet
-          size="s"
-          @click=${(e) => {
-      e.stopPropagation();
-      const newRow = {};
-      for (const [k, v] of Object.entries(itemProps)) {
-        if (v.default !== undefined) {
-          newRow[k] = v.default;
-        }
-      }
-      commit([...rows, newRow]);
-      opts.rerender?.();
-    }}
-          >+ Add</sp-action-button
-        >
-      </div>
-    `;
-  }
-  if (ps.type === "array" || ps.type === "object") {
-    return renderJsonTextField(currentValue, ps, commit);
-  }
-  let debounce;
-  const params = ctx.params ?? [];
-  const ph = ps.default !== undefined ? String(ps.default) : ps.examples?.[0] ?? "";
-  return html`<div style="display:flex;gap:4px;align-items:center">
-    <sp-textfield
-      size="s"
-      style="flex:1"
-      .value=${currentValue ?? ""}
-      placeholder=${ph || nothing}
-      title=${ps.description || nothing}
-      @input=${(e) => {
-    clearTimeout(debounce);
-    debounce = setTimeout(() => commit(e.target.value || undefined), 400);
-  }}
-    ></sp-textfield>
-    ${params.length > 0 ? html`<sp-action-button
-            quiet
-            size="s"
-            title="Bind to route param"
-            @click=${() => {
-    commit({ $ref: `#/$params/${params[0]}` });
-    opts.rerender?.();
-  }}
-            ><sp-icon-link slot="icon"></sp-icon-link
-          ></sp-action-button>` : nothing}
-  </div>`;
-}
-function renderForm(schema, value, opts) {
-  const required = new Set(schema.required);
-  const ctx = opts.context ?? NULL_CONTEXT;
-  const propertyFields = Object.entries(schema.properties ?? {}).map(([prop, ps]) => {
-    const labelText = prop + (required.has(prop) ? " *" : "");
-    return renderFieldRow({
-      hasValue: false,
-      label: labelText,
-      prop: ps.name || prop,
-      widget: renderPropertyControl(prop, ps, value, required, opts, ctx)
-    });
-  });
-  return html`${propertyFields}`;
-}
-
-// src/services/context-resolver.ts
-var PARAM_SEGMENT = /^\{@(\w+)\}$/;
-function resolveContextPointer(pointer, opts) {
-  if (!pointer.startsWith("#/$context/")) {
-    return;
-  }
-  const segments = [];
-  for (const raw of pointer.slice("#/$context/".length).split("/")) {
-    const match = raw.match(PARAM_SEGMENT);
-    if (match) {
-      const value = opts.scope?.[match[1]];
-      if (typeof value !== "string" && typeof value !== "number") {
-        return;
-      }
-      const substituted = String(value);
-      if (!substituted) {
-        return;
-      }
-      segments.push(substituted);
-    } else {
-      segments.push(raw);
-    }
-  }
-  if (segments[0] === "$formats") {
-    if (segments.length !== 1) {
-      return;
-    }
-    return (opts.formats ?? []).map((format) => format.name);
-  }
-  let node = opts.projectConfig;
-  for (const segment of segments) {
-    if (node === null || typeof node !== "object") {
-      return;
-    }
-    node = node[segment];
-  }
-  return node;
-}
-
-export { renderFieldRow, registerFormControl, renderForm, resolveContextPointer };
-
-//# debugId=C2BB6E7E97CDF54564756E2164756E21
-//# sourceMappingURL=studio-yfcstdzy.js.map