@jxsuite/studio 2.0.1 → 2.1.0

package/dist/chunks/studio-4k0m4fmp.js.map

@@ -1,13 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../node_modules/lit-html/development/directive-helpers.js", "../../../node_modules/lit-html/development/directive.js", "../../../node_modules/lit-html/development/async-directive.js", "../../../node_modules/lit-html/development/directives/ref.js"],
-  "sourcesContent": [
-    "/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport { _$LH, } from './lit-html.js';\nconst { _ChildPart: ChildPart } = _$LH;\nconst ENABLE_SHADYDOM_NOPATCH = true;\nconst wrap = ENABLE_SHADYDOM_NOPATCH &&\n    window.ShadyDOM?.inUse &&\n    window.ShadyDOM?.noPatch === true\n    ? window.ShadyDOM.wrap\n    : (node) => node;\n/**\n * Tests if a value is a primitive value.\n *\n * See https://tc39.github.io/ecma262/#sec-typeof-operator\n */\nexport const isPrimitive = (value) => value === null || (typeof value != 'object' && typeof value != 'function');\nexport const TemplateResultType = {\n    HTML: 1,\n    SVG: 2,\n    MATHML: 3,\n};\n/**\n * Tests if a value is a TemplateResult or a CompiledTemplateResult.\n */\nexport const isTemplateResult = (value, type) => type === undefined\n    ? // This property needs to remain unminified.\n        value?.['_$litType$'] !== undefined\n    : value?.['_$litType$'] === type;\n/**\n * Tests if a value is a CompiledTemplateResult.\n */\nexport const isCompiledTemplateResult = (value) => {\n    return value?.['_$litType$']?.h != null;\n};\n/**\n * Tests if a value is a DirectiveResult.\n */\nexport const isDirectiveResult = (value) => \n// This property needs to remain unminified.\nvalue?.['_$litDirective$'] !== undefined;\n/**\n * Retrieves the Directive class for a DirectiveResult\n */\nexport const getDirectiveClass = (value) => \n// This property needs to remain unminified.\nvalue?.['_$litDirective$'];\n/**\n * Tests whether a part has only a single-expression with no strings to\n * interpolate between.\n *\n * Only AttributePart and PropertyPart can have multiple expressions.\n * Multi-expression parts have a `strings` property and single-expression\n * parts do not.\n */\nexport const isSingleExpression = (part) => part.strings === undefined;\nconst createMarker = () => document.createComment('');\n/**\n * Inserts a ChildPart into the given container ChildPart's DOM, either at the\n * end of the container ChildPart, or before the optional `refPart`.\n *\n * This does not add the part to the containerPart's committed value. That must\n * be done by callers.\n *\n * @param containerPart Part within which to add the new ChildPart\n * @param refPart Part before which to add the new ChildPart; when omitted the\n *     part added to the end of the `containerPart`\n * @param part Part to insert, or undefined to create a new part\n */\nexport const insertPart = (containerPart, refPart, part) => {\n    const container = wrap(containerPart._$startNode).parentNode;\n    const refNode = refPart === undefined ? containerPart._$endNode : refPart._$startNode;\n    if (part === undefined) {\n        const startNode = wrap(container).insertBefore(createMarker(), refNode);\n        const endNode = wrap(container).insertBefore(createMarker(), refNode);\n        part = new ChildPart(startNode, endNode, containerPart, containerPart.options);\n    }\n    else {\n        const endNode = wrap(part._$endNode).nextSibling;\n        const oldParent = part._$parent;\n        const parentChanged = oldParent !== containerPart;\n        if (parentChanged) {\n            part._$reparentDisconnectables?.(containerPart);\n            // Note that although `_$reparentDisconnectables` updates the part's\n            // `_$parent` reference after unlinking from its current parent, that\n            // method only exists if Disconnectables are present, so we need to\n            // unconditionally set it here\n            part._$parent = containerPart;\n            // Since the _$isConnected getter is somewhat costly, only\n            // read it once we know the subtree has directives that need\n            // to be notified\n            let newConnectionState;\n            if (part._$notifyConnectionChanged !== undefined &&\n                (newConnectionState = containerPart._$isConnected) !==\n                    oldParent._$isConnected) {\n                part._$notifyConnectionChanged(newConnectionState);\n            }\n        }\n        if (endNode !== refNode || parentChanged) {\n            let start = part._$startNode;\n            while (start !== endNode) {\n                const n = wrap(start).nextSibling;\n                wrap(container).insertBefore(start, refNode);\n                start = n;\n            }\n        }\n    }\n    return part;\n};\n/**\n * Sets the value of a Part.\n *\n * Note that this should only be used to set/update the value of user-created\n * parts (i.e. those created using `insertPart`); it should not be used\n * by directives to set the value of the directive's container part. Directives\n * should return a value from `update`/`render` to update their part state.\n *\n * For directives that require setting their part value asynchronously, they\n * should extend `AsyncDirective` and call `this.setValue()`.\n *\n * @param part Part to set\n * @param value Value to set\n * @param index For `AttributePart`s, the index to set\n * @param directiveParent Used internally; should not be set by user\n */\nexport const setChildPartValue = (part, value, directiveParent = part) => {\n    part._$setValue(value, directiveParent);\n    return part;\n};\n// A sentinel value that can never appear as a part value except when set by\n// live(). Used to force a dirty-check to fail and cause a re-render.\nconst RESET_VALUE = {};\n/**\n * Sets the committed value of a ChildPart directly without triggering the\n * commit stage of the part.\n *\n * This is useful in cases where a directive needs to update the part such\n * that the next update detects a value change or not. When value is omitted,\n * the next update will be guaranteed to be detected as a change.\n *\n * @param part\n * @param value\n */\nexport const setCommittedValue = (part, value = RESET_VALUE) => (part._$committedValue = value);\n/**\n * Returns the committed value of a ChildPart.\n *\n * The committed value is used for change detection and efficient updates of\n * the part. It can differ from the value set by the template or directive in\n * cases where the template value is transformed before being committed.\n *\n * - `TemplateResult`s are committed as a `TemplateInstance`\n * - Iterables are committed as `Array<ChildPart>`\n * - All other types are committed as the template value or value returned or\n *   set by a directive.\n *\n * @param part\n */\nexport const getCommittedValue = (part) => part._$committedValue;\n/**\n * Removes a ChildPart from the DOM, including any of its content and markers.\n *\n * Note: The only difference between this and clearPart() is that this also\n * removes the part's start node. This means that the ChildPart must own its\n * start node, ie it must be a marker node specifically for this part and not an\n * anchor from surrounding content.\n *\n * @param part The Part to remove\n */\nexport const removePart = (part) => {\n    part._$clear();\n    part._$startNode.remove();\n};\nexport const clearPart = (part) => {\n    part._$clear();\n};\n//# sourceMappingURL=directive-helpers.js.map",
-    "/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nexport const PartType = {\n    ATTRIBUTE: 1,\n    CHILD: 2,\n    PROPERTY: 3,\n    BOOLEAN_ATTRIBUTE: 4,\n    EVENT: 5,\n    ELEMENT: 6,\n};\n/**\n * Creates a user-facing directive function from a Directive class. This\n * function has the same parameters as the directive's render() method.\n */\nexport const directive = (c) => (...values) => ({\n    // This property needs to remain unminified.\n    ['_$litDirective$']: c,\n    values,\n});\n/**\n * Base class for creating custom directives. Users should extend this class,\n * implement `render` and/or `update`, and then pass their subclass to\n * `directive`.\n */\nexport class Directive {\n    constructor(_partInfo) { }\n    // See comment in Disconnectable interface for why this is a getter\n    get _$isConnected() {\n        return this._$parent._$isConnected;\n    }\n    /** @internal */\n    _$initialize(part, parent, attributeIndex) {\n        this.__part = part;\n        this._$parent = parent;\n        this.__attributeIndex = attributeIndex;\n    }\n    /** @internal */\n    _$resolve(part, props) {\n        return this.update(part, props);\n    }\n    update(_part, props) {\n        return this.render(...props);\n    }\n}\n//# sourceMappingURL=directive.js.map",
-    "/**\n * @license\n * Copyright 2017 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport { isSingleExpression } from './directive-helpers.js';\nimport { Directive, PartType } from './directive.js';\nexport * from './directive.js';\nconst DEV_MODE = true;\n/**\n * Recursively walks down the tree of Parts/TemplateInstances/Directives to set\n * the connected state of directives and run `disconnected`/ `reconnected`\n * callbacks.\n *\n * @return True if there were children to disconnect; false otherwise\n */\nconst notifyChildrenConnectedChanged = (parent, isConnected) => {\n    const children = parent._$disconnectableChildren;\n    if (children === undefined) {\n        return false;\n    }\n    for (const obj of children) {\n        // The existence of `_$notifyDirectiveConnectionChanged` is used as a \"brand\" to\n        // disambiguate AsyncDirectives from other DisconnectableChildren\n        // (as opposed to using an instanceof check to know when to call it); the\n        // redundancy of \"Directive\" in the API name is to avoid conflicting with\n        // `_$notifyConnectionChanged`, which exists `ChildParts` which are also in\n        // this list\n        // Disconnect Directive (and any nested directives contained within)\n        // This property needs to remain unminified.\n        obj['_$notifyDirectiveConnectionChanged']?.(isConnected, false);\n        // Disconnect Part/TemplateInstance\n        notifyChildrenConnectedChanged(obj, isConnected);\n    }\n    return true;\n};\n/**\n * Removes the given child from its parent list of disconnectable children, and\n * if the parent list becomes empty as a result, removes the parent from its\n * parent, and so forth up the tree when that causes subsequent parent lists to\n * become empty.\n */\nconst removeDisconnectableFromParent = (obj) => {\n    let parent, children;\n    do {\n        if ((parent = obj._$parent) === undefined) {\n            break;\n        }\n        children = parent._$disconnectableChildren;\n        children.delete(obj);\n        obj = parent;\n    } while (children?.size === 0);\n};\nconst addDisconnectableToParent = (obj) => {\n    // Climb the parent tree, creating a sparse tree of children needing\n    // disconnection\n    for (let parent; (parent = obj._$parent); obj = parent) {\n        let children = parent._$disconnectableChildren;\n        if (children === undefined) {\n            parent._$disconnectableChildren = children = new Set();\n        }\n        else if (children.has(obj)) {\n            // Once we've reached a parent that already contains this child, we\n            // can short-circuit\n            break;\n        }\n        children.add(obj);\n        installDisconnectAPI(parent);\n    }\n};\n/**\n * Changes the parent reference of the ChildPart, and updates the sparse tree of\n * Disconnectable children accordingly.\n *\n * Note, this method will be patched onto ChildPart instances and called from\n * the core code when parts are moved between different parents.\n */\nfunction reparentDisconnectables(newParent) {\n    if (this._$disconnectableChildren !== undefined) {\n        removeDisconnectableFromParent(this);\n        this._$parent = newParent;\n        addDisconnectableToParent(this);\n    }\n    else {\n        this._$parent = newParent;\n    }\n}\n/**\n * Sets the connected state on any directives contained within the committed\n * value of this part (i.e. within a TemplateInstance or iterable of\n * ChildParts) and runs their `disconnected`/`reconnected`s, as well as within\n * any directives stored on the ChildPart (when `valueOnly` is false).\n *\n * `isClearingValue` should be passed as `true` on a top-level part that is\n * clearing itself, and not as a result of recursively disconnecting directives\n * as part of a `clear` operation higher up the tree. This both ensures that any\n * directive on this ChildPart that produced a value that caused the clear\n * operation is not disconnected, and also serves as a performance optimization\n * to avoid needless bookkeeping when a subtree is going away; when clearing a\n * subtree, only the top-most part need to remove itself from the parent.\n *\n * `fromPartIndex` is passed only in the case of a partial `_clear` running as a\n * result of truncating an iterable.\n *\n * Note, this method will be patched onto ChildPart instances and called from the\n * core code when parts are cleared or the connection state is changed by the\n * user.\n */\nfunction notifyChildPartConnectedChanged(isConnected, isClearingValue = false, fromPartIndex = 0) {\n    const value = this._$committedValue;\n    const children = this._$disconnectableChildren;\n    if (children === undefined || children.size === 0) {\n        return;\n    }\n    if (isClearingValue) {\n        if (Array.isArray(value)) {\n            // Iterable case: Any ChildParts created by the iterable should be\n            // disconnected and removed from this ChildPart's disconnectable\n            // children (starting at `fromPartIndex` in the case of truncation)\n            for (let i = fromPartIndex; i < value.length; i++) {\n                notifyChildrenConnectedChanged(value[i], false);\n                removeDisconnectableFromParent(value[i]);\n            }\n        }\n        else if (value != null) {\n            // TemplateInstance case: If the value has disconnectable children (will\n            // only be in the case that it is a TemplateInstance), we disconnect it\n            // and remove it from this ChildPart's disconnectable children\n            notifyChildrenConnectedChanged(value, false);\n            removeDisconnectableFromParent(value);\n        }\n    }\n    else {\n        notifyChildrenConnectedChanged(this, isConnected);\n    }\n}\n/**\n * Patches disconnection API onto ChildParts.\n */\nconst installDisconnectAPI = (obj) => {\n    if (obj.type == PartType.CHILD) {\n        obj._$notifyConnectionChanged ??=\n            notifyChildPartConnectedChanged;\n        obj._$reparentDisconnectables ??= reparentDisconnectables;\n    }\n};\n/**\n * An abstract `Directive` base class whose `disconnected` method will be\n * called when the part containing the directive is cleared as a result of\n * re-rendering, or when the user calls `part.setConnected(false)` on\n * a part that was previously rendered containing the directive (as happens\n * when e.g. a LitElement disconnects from the DOM).\n *\n * If `part.setConnected(true)` is subsequently called on a\n * containing part, the directive's `reconnected` method will be called prior\n * to its next `update`/`render` callbacks. When implementing `disconnected`,\n * `reconnected` should also be implemented to be compatible with reconnection.\n *\n * Note that updates may occur while the directive is disconnected. As such,\n * directives should generally check the `this.isConnected` flag during\n * render/update to determine whether it is safe to subscribe to resources\n * that may prevent garbage collection.\n */\nexport class AsyncDirective extends Directive {\n    constructor() {\n        super(...arguments);\n        // @internal\n        this._$disconnectableChildren = undefined;\n    }\n    /**\n     * Initialize the part with internal fields\n     * @param part\n     * @param parent\n     * @param attributeIndex\n     */\n    _$initialize(part, parent, attributeIndex) {\n        super._$initialize(part, parent, attributeIndex);\n        addDisconnectableToParent(this);\n        this.isConnected = part._$isConnected;\n    }\n    // This property needs to remain unminified.\n    /**\n     * Called from the core code when a directive is going away from a part (in\n     * which case `shouldRemoveFromParent` should be true), and from the\n     * `setChildrenConnected` helper function when recursively changing the\n     * connection state of a tree (in which case `shouldRemoveFromParent` should\n     * be false).\n     *\n     * @param isConnected\n     * @param isClearingDirective - True when the directive itself is being\n     *     removed; false when the tree is being disconnected\n     * @internal\n     */\n    ['_$notifyDirectiveConnectionChanged'](isConnected, isClearingDirective = true) {\n        if (isConnected !== this.isConnected) {\n            this.isConnected = isConnected;\n            if (isConnected) {\n                this.reconnected?.();\n            }\n            else {\n                this.disconnected?.();\n            }\n        }\n        if (isClearingDirective) {\n            notifyChildrenConnectedChanged(this, isConnected);\n            removeDisconnectableFromParent(this);\n        }\n    }\n    /**\n     * Sets the value of the directive's Part outside the normal `update`/`render`\n     * lifecycle of a directive.\n     *\n     * This method should not be called synchronously from a directive's `update`\n     * or `render`.\n     *\n     * @param directive The directive to update\n     * @param value The value to set\n     */\n    setValue(value) {\n        if (isSingleExpression(this.__part)) {\n            this.__part._$setValue(value, this);\n        }\n        else {\n            // this.__attributeIndex will be defined in this case, but\n            // assert it in dev mode\n            if (DEV_MODE && this.__attributeIndex === undefined) {\n                throw new Error(`Expected this.__attributeIndex to be a number`);\n            }\n            const newValues = [...this.__part._$committedValue];\n            newValues[this.__attributeIndex] = value;\n            this.__part._$setValue(newValues, this, 0);\n        }\n    }\n    /**\n     * User callbacks for implementing logic to release any resources/subscriptions\n     * that may have been retained by this directive. Since directives may also be\n     * re-connected, `reconnected` should also be implemented to restore the\n     * working state of the directive prior to the next render.\n     */\n    disconnected() { }\n    reconnected() { }\n}\n//# sourceMappingURL=async-directive.js.map",
-    "/**\n * @license\n * Copyright 2020 Google LLC\n * SPDX-License-Identifier: BSD-3-Clause\n */\nimport { nothing } from '../lit-html.js';\nimport { directive, AsyncDirective } from '../async-directive.js';\n/**\n * Creates a new Ref object, which is container for a reference to an element.\n */\nexport const createRef = () => new Ref();\n/**\n * An object that holds a ref value.\n */\nclass Ref {\n}\n// When callbacks are used for refs, this map tracks the last value the callback\n// was called with, for ensuring a directive doesn't clear the ref if the ref\n// has already been rendered to a new spot. It is double-keyed on both the\n// context (`options.host`) and the callback, since we auto-bind class methods\n// to `options.host`.\nconst lastElementForContextAndCallback = new WeakMap();\nclass RefDirective extends AsyncDirective {\n    render(_ref) {\n        return nothing;\n    }\n    update(part, [ref]) {\n        const refChanged = ref !== this._ref;\n        if (refChanged) {\n            // The ref passed to the directive has changed;\n            // unset the previous ref's value\n            this._updateRefValue(undefined);\n        }\n        if (refChanged || this._lastElementForRef !== this._element) {\n            // We either got a new ref or this is the first render;\n            // store the ref/element & update the ref value\n            this._ref = ref;\n            this._context = part.options?.host;\n            this._updateRefValue((this._element = part.element));\n        }\n        return nothing;\n    }\n    _updateRefValue(element) {\n        if (this._ref === undefined) {\n            return;\n        }\n        if (!this.isConnected) {\n            element = undefined;\n        }\n        if (typeof this._ref === 'function') {\n            // If the current ref was called with a previous value, call with\n            // `undefined`; We do this to ensure callbacks are called in a consistent\n            // way regardless of whether a ref might be moving up in the tree (in\n            // which case it would otherwise be called with the new value before the\n            // previous one unsets it) and down in the tree (where it would be unset\n            // before being set). Note that element lookup is keyed by\n            // both the context and the callback, since we allow passing unbound\n            // functions that are called on options.host, and we want to treat\n            // these as unique \"instances\" of a function.\n            const context = this._context ?? globalThis;\n            let lastElementForCallback = lastElementForContextAndCallback.get(context);\n            if (lastElementForCallback === undefined) {\n                lastElementForCallback = new WeakMap();\n                lastElementForContextAndCallback.set(context, lastElementForCallback);\n            }\n            if (lastElementForCallback.get(this._ref) !== undefined) {\n                this._ref.call(this._context, undefined);\n            }\n            lastElementForCallback.set(this._ref, element);\n            // Call the ref with the new element value\n            if (element !== undefined) {\n                this._ref.call(this._context, element);\n            }\n        }\n        else {\n            this._ref.value = element;\n        }\n    }\n    get _lastElementForRef() {\n        return typeof this._ref === 'function'\n            ? lastElementForContextAndCallback\n                .get(this._context ?? globalThis)\n                ?.get(this._ref)\n            : this._ref?.value;\n    }\n    disconnected() {\n        // Only clear the box if our element is still the one in it (i.e. another\n        // directive instance hasn't rendered its element to it before us); that\n        // only happens in the event of the directive being cleared (not via manual\n        // disconnection)\n        if (this._lastElementForRef === this._element) {\n            this._updateRefValue(undefined);\n        }\n    }\n    reconnected() {\n        // If we were manually disconnected, we can safely put our element back in\n        // the box, since no rendering could have occurred to change its state\n        this._updateRefValue(this._element);\n    }\n}\n/**\n * Sets the value of a Ref object or calls a ref callback with the element it's\n * bound to.\n *\n * A Ref object acts as a container for a reference to an element. A ref\n * callback is a function that takes an element as its only argument.\n *\n * The ref directive sets the value of the Ref object or calls the ref callback\n * during rendering, if the referenced element changed.\n *\n * Note: If a ref callback is rendered to a different element position or is\n * removed in a subsequent render, it will first be called with `undefined`,\n * followed by another call with the new element it was rendered to (if any).\n *\n * ```js\n * // Using Ref object\n * const inputRef = createRef();\n * render(html`<input ${ref(inputRef)}>`, container);\n * inputRef.value.focus();\n *\n * // Using callback\n * const callback = (inputElement) => inputElement.focus();\n * render(html`<input ${ref(callback)}>`, container);\n * ```\n */\nexport const ref = directive(RefDirective);\n//# sourceMappingURL=ref.js.map"
-  ],
-  "mappings": "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",
-  "debugId": "D29D8124A0D6485D64756E2164756E21",
-  "names": []
-}

package/dist/chunks/studio-9smfzqhc.js

@@ -1,19 +0,0 @@
-// src/platform.ts
-var g = globalThis;
-function registerPlatform(platform) {
-  g.__jxPlatform = platform;
-}
-function getPlatform() {
-  if (!g.__jxPlatform) {
-    throw new Error("No platform registered. Call registerPlatform() before starting Studio.");
-  }
-  return g.__jxPlatform;
-}
-function hasPlatform() {
-  return g.__jxPlatform != null;
-}
-
-export { registerPlatform, getPlatform, hasPlatform };
-
-//# debugId=017022B39082A09464756E2164756E21
-//# sourceMappingURL=studio-9smfzqhc.js.map

package/dist/chunks/studio-9smfzqhc.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/platform.ts"],
-  "sourcesContent": [
-    "/// <reference lib=\"dom\" />\n/**\n * Platform.js — Platform Abstraction Layer (PAL)\n *\n * Studio is backend-agnostic. Each deployment target (desktop, dev server, cloud) registers a\n * platform adapter at startup. All file I/O, project loading, and component discovery goes through\n * this interface.\n *\n * Uses window.__jxPlatform so the platform can be registered from a separate script bundle (e.g.\n * init.js) before studio.js loads.\n *\n * See spec/desktop.md §3 for the full StudioPlatform interface.\n */\n\nimport type { StudioPlatform } from \"./types\";\n\nconst g = globalThis as unknown as { __jxPlatform?: StudioPlatform };\n\n/** @param {StudioPlatform} platform */\nexport function registerPlatform(platform: StudioPlatform) {\n  g.__jxPlatform = platform;\n}\n\n/** @returns {StudioPlatform} */\nexport function getPlatform() {\n  if (!g.__jxPlatform) {\n    throw new Error(\"No platform registered. Call registerPlatform() before starting Studio.\");\n  }\n  return g.__jxPlatform;\n}\n\n/** @returns {boolean} */\nexport function hasPlatform() {\n  return g.__jxPlatform != null;\n}\n"
-  ],
-  "mappings": ";AAgBA,IAAM,IAAI;AAGH,SAAS,gBAAgB,CAAC,UAA0B;AAAA,EACzD,EAAE,eAAe;AAAA;AAIZ,SAAS,WAAW,GAAG;AAAA,EAC5B,IAAI,CAAC,EAAE,cAAc;AAAA,IACnB,MAAM,IAAI,MAAM,yEAAyE;AAAA,EAC3F;AAAA,EACA,OAAO,EAAE;AAAA;AAIJ,SAAS,WAAW,GAAG;AAAA,EAC5B,OAAO,EAAE,gBAAgB;AAAA;",
-  "debugId": "017022B39082A09464756E2164756E21",
-  "names": []
-}