@shopify/cli-kit 2.0.2 → 2.0.3

package/dist/{index-0f69cf26.js → index-cee0245d.js}

@@ -142,7 +142,7 @@ Reflect.defineProperty(module.exports, 'windows', { enumerable: false, value: wi
 Reflect.defineProperty(module.exports, 'other', { enumerable: false, value: other });
 }(symbols$2));
 
-const isObject$5 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+const isObject$6 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
 
 /* eslint-disable no-control-regex */
 // this is a modified version of https://github.com/chalk/ansi-regex (MIT License)
@@ -290,7 +290,7 @@ const create$3 = () => {
   };
 
   colors.theme = custom => {
-    if (!isObject$5(custom)) throw new TypeError('Expected theme to be an object');
+    if (!isObject$6(custom)) throw new TypeError('Expected theme to be an object');
     for (let name of Object.keys(custom)) {
       colors.alias(name, custom[name]);
     }
@@ -1884,7 +1884,7 @@ const colors$5 = ansiColors.exports;
 const Prompt$5 = prompt$1;
 const roles = roles_1;
 const utils$t = utils$z;
-const { reorder, scrollUp, scrollDown, isObject: isObject$4, swap } = utils$t;
+const { reorder, scrollUp, scrollDown, isObject: isObject$5, swap } = utils$t;
 
 class ArrayPrompt$3 extends Prompt$5 {
   constructor(options) {
@@ -1918,7 +1918,7 @@ class ArrayPrompt$3 extends Prompt$5 {
       throw new Error('At least one choice must be selectable');
     }
 
-    if (isObject$4(initial)) initial = Object.keys(initial);
+    if (isObject$5(initial)) initial = Object.keys(initial);
     if (Array.isArray(initial)) {
       if (autofocus != null) this.index = this.findIndex(autofocus);
       initial.forEach(v => this.enable(this.find(v)));
@@ -2394,7 +2394,7 @@ class ArrayPrompt$3 extends Prompt$5 {
   }
 
   find(value, prop) {
-    if (isObject$4(value)) return prop ? value[prop] : value;
+    if (isObject$5(value)) return prop ? value[prop] : value;
     let isChoice = (ele, i) => [ele.name, i].includes(value);
     let fn = typeof value === 'function' ? value : isChoice;
     let choice = this.choices.find(fn);
@@ -8240,7 +8240,7 @@ onetime$3.exports.callCount = function_ => {
 
 var signalExit$1 = {exports: {}};
 
-var signals$1 = {exports: {}};
+var signals$2 = {exports: {}};
 
 (function (module) {
 // This is not the set of all possible signals.
@@ -8296,7 +8296,7 @@ if (process.platform === 'linux') {
     'SIGUNUSED'
   );
 }
-}(signals$1));
+}(signals$2));
 
 // Note: since nyc uses this module to output coverage, any lines
 // that are in the direct sync flow of nyc's outputCoverage are
@@ -8324,7 +8324,7 @@ if (!processOk(process$1)) {
   };
 } else {
   var assert$3 = require$$0$4;
-  var signals = signals$1.exports;
+  var signals$1 = signals$2.exports;
   var isWin$2 = /^win/i.test(process$1.platform);
 
   var EE = require$$0$3;
@@ -8385,7 +8385,7 @@ if (!processOk(process$1)) {
     }
     loaded = false;
 
-    signals.forEach(function (sig) {
+    signals$1.forEach(function (sig) {
       try {
         process$1.removeListener(sig, sigListeners[sig]);
       } catch (er) {}
@@ -8407,7 +8407,7 @@ if (!processOk(process$1)) {
 
   // { <signal>: <listener fn>, ... }
   var sigListeners = {};
-  signals.forEach(function (sig) {
+  signals$1.forEach(function (sig) {
     sigListeners[sig] = function listener () {
       /* istanbul ignore if */
       if (!processOk(commonjsGlobal.process)) {
@@ -8436,7 +8436,7 @@ if (!processOk(process$1)) {
   });
 
   signalExit$1.exports.signals = function () {
-    return signals
+    return signals$1
   };
 
   var loaded = false;
@@ -8453,7 +8453,7 @@ if (!processOk(process$1)) {
     // handle it instead of us.
     emitter.count += 1;
 
-    signals = signals.filter(function (sig) {
+    signals$1 = signals$1.filter(function (sig) {
       try {
         process$1.on(sig, sigListeners[sig]);
         return true
@@ -11833,7 +11833,7 @@ var toRegexRange_1 = toRegexRange$1;
 const util$9 = require$$0$7;
 const toRegexRange = toRegexRange_1;
 
-const isObject$3 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+const isObject$4 = val => val !== null && typeof val === 'object' && !Array.isArray(val);
 
 const transform$1 = toNumber => {
   return value => toNumber === true ? Number(value) : String(value);
@@ -12049,7 +12049,7 @@ const fill$2 = (start, end, step, options = {}) => {
     return fill$2(start, end, 1, { transform: step });
   }
 
-  if (isObject$3(step)) {
+  if (isObject$4(step)) {
     return fill$2(start, end, 0, step);
   }
 
@@ -12058,7 +12058,7 @@ const fill$2 = (start, end, step, options = {}) => {
   step = step || opts.step || 1;
 
   if (!isNumber$3(step)) {
-    if (step != null && !isObject$3(step)) return invalidStep(step, opts);
+    if (step != null && !isObject$4(step)) return invalidStep(step, opts);
     return fill$2(start, end, 1, step);
   }
 
@@ -14524,7 +14524,7 @@ const scan = scan_1;
 const parse$d = parse_1$2;
 const utils$g = utils$j;
 const constants$4 = constants$6;
-const isObject$2 = val => val && typeof val === 'object' && !Array.isArray(val);
+const isObject$3 = val => val && typeof val === 'object' && !Array.isArray(val);
 
 /**
  * Creates a matcher function from one or more glob patterns. The
@@ -14561,7 +14561,7 @@ const picomatch$2 = (glob, options, returnState = false) => {
     return arrayMatcher;
   }
 
-  const isState = isObject$2(glob) && glob.tokens && glob.input;
+  const isState = isObject$3(glob) && glob.tokens && glob.input;
 
   if (glob === '' || (typeof glob !== 'string' && !isState)) {
     throw new TypeError('Expected pattern to be a non-empty string');
@@ -17656,7 +17656,7 @@ var path$w = /*#__PURE__*/Object.freeze({
 });
 
 var name = "@shopify/cli-kit";
-var version$4 = "2.0.2";
+var version$4 = "2.0.3";
 var description$1 = "A set of utilities, interfaces, and models that are common across all the platform features";
 var keywords = [
 	"shopify",
@@ -17715,6 +17715,7 @@ var devDependencies = {
 	"@types/cross-zip": "^4.0.0",
 	"@types/js-yaml": "^4.0.5",
 	"@types/semver": "^7.3.9",
+	"abort-controller": "^3.0.0",
 	"ansi-colors": "^4.1.1",
 	"change-case": "^4.1.2",
 	commondir: "^1.0.1",
@@ -17769,11 +17770,11 @@ var cliKitPackageJson = {
 	devDependencies: devDependencies
 };
 
-var version$3 = "2.0.2";
+var version$3 = "2.0.3";
 
-var version$2 = "2.0.2";
+var version$2 = "2.0.3";
 
-var version$1 = "2.0.2";
+var version$1 = "2.0.3";
 
 const homedir$1 = os$8.homedir();
 const tmpdir$1 = os$8.tmpdir();
@@ -24970,6 +24971,979 @@ terminalLink.isSupported = supportsHyperlinks.stdout;
 terminalLink.stderr = (text, url, options = {}) => terminalLink(text, url, {target: 'stderr', ...options});
 terminalLink.stderr.isSupported = supportsHyperlinks.stderr;
 
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * @copyright 2015 Toru Nagashima. All rights reserved.
+ * See LICENSE file in root directory for full license.
+ */
+/**
+ * @typedef {object} PrivateData
+ * @property {EventTarget} eventTarget The event target.
+ * @property {{type:string}} event The original event object.
+ * @property {number} eventPhase The current event phase.
+ * @property {EventTarget|null} currentTarget The current event target.
+ * @property {boolean} canceled The flag to prevent default.
+ * @property {boolean} stopped The flag to stop propagation.
+ * @property {boolean} immediateStopped The flag to stop propagation immediately.
+ * @property {Function|null} passiveListener The listener if the current listener is passive. Otherwise this is null.
+ * @property {number} timeStamp The unix time.
+ * @private
+ */
+
+/**
+ * Private data for event wrappers.
+ * @type {WeakMap<Event, PrivateData>}
+ * @private
+ */
+const privateData = new WeakMap();
+
+/**
+ * Cache for wrapper classes.
+ * @type {WeakMap<Object, Function>}
+ * @private
+ */
+const wrappers = new WeakMap();
+
+/**
+ * Get private data.
+ * @param {Event} event The event object to get private data.
+ * @returns {PrivateData} The private data of the event.
+ * @private
+ */
+function pd(event) {
+    const retv = privateData.get(event);
+    console.assert(
+        retv != null,
+        "'this' is expected an Event object, but got",
+        event
+    );
+    return retv
+}
+
+/**
+ * https://dom.spec.whatwg.org/#set-the-canceled-flag
+ * @param data {PrivateData} private data.
+ */
+function setCancelFlag(data) {
+    if (data.passiveListener != null) {
+        if (
+            typeof console !== "undefined" &&
+            typeof console.error === "function"
+        ) {
+            console.error(
+                "Unable to preventDefault inside passive event listener invocation.",
+                data.passiveListener
+            );
+        }
+        return
+    }
+    if (!data.event.cancelable) {
+        return
+    }
+
+    data.canceled = true;
+    if (typeof data.event.preventDefault === "function") {
+        data.event.preventDefault();
+    }
+}
+
+/**
+ * @see https://dom.spec.whatwg.org/#interface-event
+ * @private
+ */
+/**
+ * The event wrapper.
+ * @constructor
+ * @param {EventTarget} eventTarget The event target of this dispatching.
+ * @param {Event|{type:string}} event The original event to wrap.
+ */
+function Event(eventTarget, event) {
+    privateData.set(this, {
+        eventTarget,
+        event,
+        eventPhase: 2,
+        currentTarget: eventTarget,
+        canceled: false,
+        stopped: false,
+        immediateStopped: false,
+        passiveListener: null,
+        timeStamp: event.timeStamp || Date.now(),
+    });
+
+    // https://heycam.github.io/webidl/#Unforgeable
+    Object.defineProperty(this, "isTrusted", { value: false, enumerable: true });
+
+    // Define accessors
+    const keys = Object.keys(event);
+    for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        if (!(key in this)) {
+            Object.defineProperty(this, key, defineRedirectDescriptor(key));
+        }
+    }
+}
+
+// Should be enumerable, but class methods are not enumerable.
+Event.prototype = {
+    /**
+     * The type of this event.
+     * @type {string}
+     */
+    get type() {
+        return pd(this).event.type
+    },
+
+    /**
+     * The target of this event.
+     * @type {EventTarget}
+     */
+    get target() {
+        return pd(this).eventTarget
+    },
+
+    /**
+     * The target of this event.
+     * @type {EventTarget}
+     */
+    get currentTarget() {
+        return pd(this).currentTarget
+    },
+
+    /**
+     * @returns {EventTarget[]} The composed path of this event.
+     */
+    composedPath() {
+        const currentTarget = pd(this).currentTarget;
+        if (currentTarget == null) {
+            return []
+        }
+        return [currentTarget]
+    },
+
+    /**
+     * Constant of NONE.
+     * @type {number}
+     */
+    get NONE() {
+        return 0
+    },
+
+    /**
+     * Constant of CAPTURING_PHASE.
+     * @type {number}
+     */
+    get CAPTURING_PHASE() {
+        return 1
+    },
+
+    /**
+     * Constant of AT_TARGET.
+     * @type {number}
+     */
+    get AT_TARGET() {
+        return 2
+    },
+
+    /**
+     * Constant of BUBBLING_PHASE.
+     * @type {number}
+     */
+    get BUBBLING_PHASE() {
+        return 3
+    },
+
+    /**
+     * The target of this event.
+     * @type {number}
+     */
+    get eventPhase() {
+        return pd(this).eventPhase
+    },
+
+    /**
+     * Stop event bubbling.
+     * @returns {void}
+     */
+    stopPropagation() {
+        const data = pd(this);
+
+        data.stopped = true;
+        if (typeof data.event.stopPropagation === "function") {
+            data.event.stopPropagation();
+        }
+    },
+
+    /**
+     * Stop event bubbling.
+     * @returns {void}
+     */
+    stopImmediatePropagation() {
+        const data = pd(this);
+
+        data.stopped = true;
+        data.immediateStopped = true;
+        if (typeof data.event.stopImmediatePropagation === "function") {
+            data.event.stopImmediatePropagation();
+        }
+    },
+
+    /**
+     * The flag to be bubbling.
+     * @type {boolean}
+     */
+    get bubbles() {
+        return Boolean(pd(this).event.bubbles)
+    },
+
+    /**
+     * The flag to be cancelable.
+     * @type {boolean}
+     */
+    get cancelable() {
+        return Boolean(pd(this).event.cancelable)
+    },
+
+    /**
+     * Cancel this event.
+     * @returns {void}
+     */
+    preventDefault() {
+        setCancelFlag(pd(this));
+    },
+
+    /**
+     * The flag to indicate cancellation state.
+     * @type {boolean}
+     */
+    get defaultPrevented() {
+        return pd(this).canceled
+    },
+
+    /**
+     * The flag to be composed.
+     * @type {boolean}
+     */
+    get composed() {
+        return Boolean(pd(this).event.composed)
+    },
+
+    /**
+     * The unix time of this event.
+     * @type {number}
+     */
+    get timeStamp() {
+        return pd(this).timeStamp
+    },
+
+    /**
+     * The target of this event.
+     * @type {EventTarget}
+     * @deprecated
+     */
+    get srcElement() {
+        return pd(this).eventTarget
+    },
+
+    /**
+     * The flag to stop event bubbling.
+     * @type {boolean}
+     * @deprecated
+     */
+    get cancelBubble() {
+        return pd(this).stopped
+    },
+    set cancelBubble(value) {
+        if (!value) {
+            return
+        }
+        const data = pd(this);
+
+        data.stopped = true;
+        if (typeof data.event.cancelBubble === "boolean") {
+            data.event.cancelBubble = true;
+        }
+    },
+
+    /**
+     * The flag to indicate cancellation state.
+     * @type {boolean}
+     * @deprecated
+     */
+    get returnValue() {
+        return !pd(this).canceled
+    },
+    set returnValue(value) {
+        if (!value) {
+            setCancelFlag(pd(this));
+        }
+    },
+
+    /**
+     * Initialize this event object. But do nothing under event dispatching.
+     * @param {string} type The event type.
+     * @param {boolean} [bubbles=false] The flag to be possible to bubble up.
+     * @param {boolean} [cancelable=false] The flag to be possible to cancel.
+     * @deprecated
+     */
+    initEvent() {
+        // Do nothing.
+    },
+};
+
+// `constructor` is not enumerable.
+Object.defineProperty(Event.prototype, "constructor", {
+    value: Event,
+    configurable: true,
+    writable: true,
+});
+
+// Ensure `event instanceof window.Event` is `true`.
+if (typeof window !== "undefined" && typeof window.Event !== "undefined") {
+    Object.setPrototypeOf(Event.prototype, window.Event.prototype);
+
+    // Make association for wrappers.
+    wrappers.set(window.Event.prototype, Event);
+}
+
+/**
+ * Get the property descriptor to redirect a given property.
+ * @param {string} key Property name to define property descriptor.
+ * @returns {PropertyDescriptor} The property descriptor to redirect the property.
+ * @private
+ */
+function defineRedirectDescriptor(key) {
+    return {
+        get() {
+            return pd(this).event[key]
+        },
+        set(value) {
+            pd(this).event[key] = value;
+        },
+        configurable: true,
+        enumerable: true,
+    }
+}
+
+/**
+ * Get the property descriptor to call a given method property.
+ * @param {string} key Property name to define property descriptor.
+ * @returns {PropertyDescriptor} The property descriptor to call the method property.
+ * @private
+ */
+function defineCallDescriptor(key) {
+    return {
+        value() {
+            const event = pd(this).event;
+            return event[key].apply(event, arguments)
+        },
+        configurable: true,
+        enumerable: true,
+    }
+}
+
+/**
+ * Define new wrapper class.
+ * @param {Function} BaseEvent The base wrapper class.
+ * @param {Object} proto The prototype of the original event.
+ * @returns {Function} The defined wrapper class.
+ * @private
+ */
+function defineWrapper(BaseEvent, proto) {
+    const keys = Object.keys(proto);
+    if (keys.length === 0) {
+        return BaseEvent
+    }
+
+    /** CustomEvent */
+    function CustomEvent(eventTarget, event) {
+        BaseEvent.call(this, eventTarget, event);
+    }
+
+    CustomEvent.prototype = Object.create(BaseEvent.prototype, {
+        constructor: { value: CustomEvent, configurable: true, writable: true },
+    });
+
+    // Define accessors.
+    for (let i = 0; i < keys.length; ++i) {
+        const key = keys[i];
+        if (!(key in BaseEvent.prototype)) {
+            const descriptor = Object.getOwnPropertyDescriptor(proto, key);
+            const isFunc = typeof descriptor.value === "function";
+            Object.defineProperty(
+                CustomEvent.prototype,
+                key,
+                isFunc
+                    ? defineCallDescriptor(key)
+                    : defineRedirectDescriptor(key)
+            );
+        }
+    }
+
+    return CustomEvent
+}
+
+/**
+ * Get the wrapper class of a given prototype.
+ * @param {Object} proto The prototype of the original event to get its wrapper.
+ * @returns {Function} The wrapper class.
+ * @private
+ */
+function getWrapper(proto) {
+    if (proto == null || proto === Object.prototype) {
+        return Event
+    }
+
+    let wrapper = wrappers.get(proto);
+    if (wrapper == null) {
+        wrapper = defineWrapper(getWrapper(Object.getPrototypeOf(proto)), proto);
+        wrappers.set(proto, wrapper);
+    }
+    return wrapper
+}
+
+/**
+ * Wrap a given event to management a dispatching.
+ * @param {EventTarget} eventTarget The event target of this dispatching.
+ * @param {Object} event The event to wrap.
+ * @returns {Event} The wrapper instance.
+ * @private
+ */
+function wrapEvent(eventTarget, event) {
+    const Wrapper = getWrapper(Object.getPrototypeOf(event));
+    return new Wrapper(eventTarget, event)
+}
+
+/**
+ * Get the immediateStopped flag of a given event.
+ * @param {Event} event The event to get.
+ * @returns {boolean} The flag to stop propagation immediately.
+ * @private
+ */
+function isStopped(event) {
+    return pd(event).immediateStopped
+}
+
+/**
+ * Set the current event phase of a given event.
+ * @param {Event} event The event to set current target.
+ * @param {number} eventPhase New event phase.
+ * @returns {void}
+ * @private
+ */
+function setEventPhase(event, eventPhase) {
+    pd(event).eventPhase = eventPhase;
+}
+
+/**
+ * Set the current target of a given event.
+ * @param {Event} event The event to set current target.
+ * @param {EventTarget|null} currentTarget New current target.
+ * @returns {void}
+ * @private
+ */
+function setCurrentTarget(event, currentTarget) {
+    pd(event).currentTarget = currentTarget;
+}
+
+/**
+ * Set a passive listener of a given event.
+ * @param {Event} event The event to set current target.
+ * @param {Function|null} passiveListener New passive listener.
+ * @returns {void}
+ * @private
+ */
+function setPassiveListener(event, passiveListener) {
+    pd(event).passiveListener = passiveListener;
+}
+
+/**
+ * @typedef {object} ListenerNode
+ * @property {Function} listener
+ * @property {1|2|3} listenerType
+ * @property {boolean} passive
+ * @property {boolean} once
+ * @property {ListenerNode|null} next
+ * @private
+ */
+
+/**
+ * @type {WeakMap<object, Map<string, ListenerNode>>}
+ * @private
+ */
+const listenersMap = new WeakMap();
+
+// Listener types
+const CAPTURE = 1;
+const BUBBLE = 2;
+const ATTRIBUTE = 3;
+
+/**
+ * Check whether a given value is an object or not.
+ * @param {any} x The value to check.
+ * @returns {boolean} `true` if the value is an object.
+ */
+function isObject$2(x) {
+    return x !== null && typeof x === "object" //eslint-disable-line no-restricted-syntax
+}
+
+/**
+ * Get listeners.
+ * @param {EventTarget} eventTarget The event target to get.
+ * @returns {Map<string, ListenerNode>} The listeners.
+ * @private
+ */
+function getListeners(eventTarget) {
+    const listeners = listenersMap.get(eventTarget);
+    if (listeners == null) {
+        throw new TypeError(
+            "'this' is expected an EventTarget object, but got another value."
+        )
+    }
+    return listeners
+}
+
+/**
+ * Get the property descriptor for the event attribute of a given event.
+ * @param {string} eventName The event name to get property descriptor.
+ * @returns {PropertyDescriptor} The property descriptor.
+ * @private
+ */
+function defineEventAttributeDescriptor(eventName) {
+    return {
+        get() {
+            const listeners = getListeners(this);
+            let node = listeners.get(eventName);
+            while (node != null) {
+                if (node.listenerType === ATTRIBUTE) {
+                    return node.listener
+                }
+                node = node.next;
+            }
+            return null
+        },
+
+        set(listener) {
+            if (typeof listener !== "function" && !isObject$2(listener)) {
+                listener = null; // eslint-disable-line no-param-reassign
+            }
+            const listeners = getListeners(this);
+
+            // Traverse to the tail while removing old value.
+            let prev = null;
+            let node = listeners.get(eventName);
+            while (node != null) {
+                if (node.listenerType === ATTRIBUTE) {
+                    // Remove old value.
+                    if (prev !== null) {
+                        prev.next = node.next;
+                    } else if (node.next !== null) {
+                        listeners.set(eventName, node.next);
+                    } else {
+                        listeners.delete(eventName);
+                    }
+                } else {
+                    prev = node;
+                }
+
+                node = node.next;
+            }
+
+            // Add new value.
+            if (listener !== null) {
+                const newNode = {
+                    listener,
+                    listenerType: ATTRIBUTE,
+                    passive: false,
+                    once: false,
+                    next: null,
+                };
+                if (prev === null) {
+                    listeners.set(eventName, newNode);
+                } else {
+                    prev.next = newNode;
+                }
+            }
+        },
+        configurable: true,
+        enumerable: true,
+    }
+}
+
+/**
+ * Define an event attribute (e.g. `eventTarget.onclick`).
+ * @param {Object} eventTargetPrototype The event target prototype to define an event attrbite.
+ * @param {string} eventName The event name to define.
+ * @returns {void}
+ */
+function defineEventAttribute(eventTargetPrototype, eventName) {
+    Object.defineProperty(
+        eventTargetPrototype,
+        `on${eventName}`,
+        defineEventAttributeDescriptor(eventName)
+    );
+}
+
+/**
+ * Define a custom EventTarget with event attributes.
+ * @param {string[]} eventNames Event names for event attributes.
+ * @returns {EventTarget} The custom EventTarget.
+ * @private
+ */
+function defineCustomEventTarget(eventNames) {
+    /** CustomEventTarget */
+    function CustomEventTarget() {
+        EventTarget.call(this);
+    }
+
+    CustomEventTarget.prototype = Object.create(EventTarget.prototype, {
+        constructor: {
+            value: CustomEventTarget,
+            configurable: true,
+            writable: true,
+        },
+    });
+
+    for (let i = 0; i < eventNames.length; ++i) {
+        defineEventAttribute(CustomEventTarget.prototype, eventNames[i]);
+    }
+
+    return CustomEventTarget
+}
+
+/**
+ * EventTarget.
+ *
+ * - This is constructor if no arguments.
+ * - This is a function which returns a CustomEventTarget constructor if there are arguments.
+ *
+ * For example:
+ *
+ *     class A extends EventTarget {}
+ *     class B extends EventTarget("message") {}
+ *     class C extends EventTarget("message", "error") {}
+ *     class D extends EventTarget(["message", "error"]) {}
+ */
+function EventTarget() {
+    /*eslint-disable consistent-return */
+    if (this instanceof EventTarget) {
+        listenersMap.set(this, new Map());
+        return
+    }
+    if (arguments.length === 1 && Array.isArray(arguments[0])) {
+        return defineCustomEventTarget(arguments[0])
+    }
+    if (arguments.length > 0) {
+        const types = new Array(arguments.length);
+        for (let i = 0; i < arguments.length; ++i) {
+            types[i] = arguments[i];
+        }
+        return defineCustomEventTarget(types)
+    }
+    throw new TypeError("Cannot call a class as a function")
+    /*eslint-enable consistent-return */
+}
+
+// Should be enumerable, but class methods are not enumerable.
+EventTarget.prototype = {
+    /**
+     * Add a given listener to this event target.
+     * @param {string} eventName The event name to add.
+     * @param {Function} listener The listener to add.
+     * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
+     * @returns {void}
+     */
+    addEventListener(eventName, listener, options) {
+        if (listener == null) {
+            return
+        }
+        if (typeof listener !== "function" && !isObject$2(listener)) {
+            throw new TypeError("'listener' should be a function or an object.")
+        }
+
+        const listeners = getListeners(this);
+        const optionsIsObj = isObject$2(options);
+        const capture = optionsIsObj
+            ? Boolean(options.capture)
+            : Boolean(options);
+        const listenerType = capture ? CAPTURE : BUBBLE;
+        const newNode = {
+            listener,
+            listenerType,
+            passive: optionsIsObj && Boolean(options.passive),
+            once: optionsIsObj && Boolean(options.once),
+            next: null,
+        };
+
+        // Set it as the first node if the first node is null.
+        let node = listeners.get(eventName);
+        if (node === undefined) {
+            listeners.set(eventName, newNode);
+            return
+        }
+
+        // Traverse to the tail while checking duplication..
+        let prev = null;
+        while (node != null) {
+            if (
+                node.listener === listener &&
+                node.listenerType === listenerType
+            ) {
+                // Should ignore duplication.
+                return
+            }
+            prev = node;
+            node = node.next;
+        }
+
+        // Add it.
+        prev.next = newNode;
+    },
+
+    /**
+     * Remove a given listener from this event target.
+     * @param {string} eventName The event name to remove.
+     * @param {Function} listener The listener to remove.
+     * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
+     * @returns {void}
+     */
+    removeEventListener(eventName, listener, options) {
+        if (listener == null) {
+            return
+        }
+
+        const listeners = getListeners(this);
+        const capture = isObject$2(options)
+            ? Boolean(options.capture)
+            : Boolean(options);
+        const listenerType = capture ? CAPTURE : BUBBLE;
+
+        let prev = null;
+        let node = listeners.get(eventName);
+        while (node != null) {
+            if (
+                node.listener === listener &&
+                node.listenerType === listenerType
+            ) {
+                if (prev !== null) {
+                    prev.next = node.next;
+                } else if (node.next !== null) {
+                    listeners.set(eventName, node.next);
+                } else {
+                    listeners.delete(eventName);
+                }
+                return
+            }
+
+            prev = node;
+            node = node.next;
+        }
+    },
+
+    /**
+     * Dispatch a given event.
+     * @param {Event|{type:string}} event The event to dispatch.
+     * @returns {boolean} `false` if canceled.
+     */
+    dispatchEvent(event) {
+        if (event == null || typeof event.type !== "string") {
+            throw new TypeError('"event.type" should be a string.')
+        }
+
+        // If listeners aren't registered, terminate.
+        const listeners = getListeners(this);
+        const eventName = event.type;
+        let node = listeners.get(eventName);
+        if (node == null) {
+            return true
+        }
+
+        // Since we cannot rewrite several properties, so wrap object.
+        const wrappedEvent = wrapEvent(this, event);
+
+        // This doesn't process capturing phase and bubbling phase.
+        // This isn't participating in a tree.
+        let prev = null;
+        while (node != null) {
+            // Remove this listener if it's once
+            if (node.once) {
+                if (prev !== null) {
+                    prev.next = node.next;
+                } else if (node.next !== null) {
+                    listeners.set(eventName, node.next);
+                } else {
+                    listeners.delete(eventName);
+                }
+            } else {
+                prev = node;
+            }
+
+            // Call this listener
+            setPassiveListener(
+                wrappedEvent,
+                node.passive ? node.listener : null
+            );
+            if (typeof node.listener === "function") {
+                try {
+                    node.listener.call(this, wrappedEvent);
+                } catch (err) {
+                    if (
+                        typeof console !== "undefined" &&
+                        typeof console.error === "function"
+                    ) {
+                        console.error(err);
+                    }
+                }
+            } else if (
+                node.listenerType !== ATTRIBUTE &&
+                typeof node.listener.handleEvent === "function"
+            ) {
+                node.listener.handleEvent(wrappedEvent);
+            }
+
+            // Break if `event.stopImmediatePropagation` was called.
+            if (isStopped(wrappedEvent)) {
+                break
+            }
+
+            node = node.next;
+        }
+        setPassiveListener(wrappedEvent, null);
+        setEventPhase(wrappedEvent, 0);
+        setCurrentTarget(wrappedEvent, null);
+
+        return !wrappedEvent.defaultPrevented
+    },
+};
+
+// `constructor` is not enumerable.
+Object.defineProperty(EventTarget.prototype, "constructor", {
+    value: EventTarget,
+    configurable: true,
+    writable: true,
+});
+
+// Ensure `eventTarget instanceof window.EventTarget` is `true`.
+if (
+    typeof window !== "undefined" &&
+    typeof window.EventTarget !== "undefined"
+) {
+    Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype);
+}
+
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+/**
+ * The signal class.
+ * @see https://dom.spec.whatwg.org/#abortsignal
+ */
+class AbortSignal extends EventTarget {
+    /**
+     * AbortSignal cannot be constructed directly.
+     */
+    constructor() {
+        super();
+        throw new TypeError("AbortSignal cannot be constructed directly");
+    }
+    /**
+     * Returns `true` if this `AbortSignal`'s `AbortController` has signaled to abort, and `false` otherwise.
+     */
+    get aborted() {
+        const aborted = abortedFlags.get(this);
+        if (typeof aborted !== "boolean") {
+            throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? "null" : typeof this}`);
+        }
+        return aborted;
+    }
+}
+defineEventAttribute(AbortSignal.prototype, "abort");
+/**
+ * Create an AbortSignal object.
+ */
+function createAbortSignal() {
+    const signal = Object.create(AbortSignal.prototype);
+    EventTarget.call(signal);
+    abortedFlags.set(signal, false);
+    return signal;
+}
+/**
+ * Abort a given signal.
+ */
+function abortSignal(signal) {
+    if (abortedFlags.get(signal) !== false) {
+        return;
+    }
+    abortedFlags.set(signal, true);
+    signal.dispatchEvent({ type: "abort" });
+}
+/**
+ * Aborted flag for each instances.
+ */
+const abortedFlags = new WeakMap();
+// Properties should be enumerable.
+Object.defineProperties(AbortSignal.prototype, {
+    aborted: { enumerable: true },
+});
+// `toString()` should return `"[object AbortSignal]"`
+if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+    Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {
+        configurable: true,
+        value: "AbortSignal",
+    });
+}
+
+/**
+ * The AbortController.
+ * @see https://dom.spec.whatwg.org/#abortcontroller
+ */
+class AbortController$1 {
+    /**
+     * Initialize this controller.
+     */
+    constructor() {
+        signals.set(this, createAbortSignal());
+    }
+    /**
+     * Returns the `AbortSignal` object associated with this object.
+     */
+    get signal() {
+        return getSignal(this);
+    }
+    /**
+     * Abort and signal to any observers that the associated activity is to be aborted.
+     */
+    abort() {
+        abortSignal(getSignal(this));
+    }
+}
+/**
+ * Associated signals.
+ */
+const signals = new WeakMap();
+/**
+ * Get the associated signal of a given controller.
+ */
+function getSignal(controller) {
+    const signal = signals.get(controller);
+    if (signal == null) {
+        throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${controller === null ? "null" : typeof controller}`);
+    }
+    return signal;
+}
+// Properties should be enumerable.
+Object.defineProperties(AbortController$1.prototype, {
+    signal: { enumerable: true },
+    abort: { enumerable: true },
+});
+if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
+    Object.defineProperty(AbortController$1.prototype, Symbol.toStringTag, {
+        configurable: true,
+        value: "AbortController",
+    });
+}
+
 class ContentToken {
   constructor(value, metadata = {}, type) {
     this.type = type;
@@ -25086,7 +26060,7 @@ const success = (content2) => {
   }
 };
 const debug$5 = (content2) => {
-  message(content2, "debug");
+  message(colors$9.gray(stringifyMessage(content2)), "debug");
 };
 const warn = (content2) => {
   consoleWarn(colors$9.yellow(stringifyMessage(content2)));
@@ -25153,7 +26127,7 @@ const message = (content2, level = "info") => {
   }
 };
 async function concurrent(processes) {
-  const abortController = new AbortController();
+  const abortController = new AbortController$1();
   const concurrentColors = [token.yellow, token.cyan, token.magenta, token.green];
   const prefixColumnSize = Math.max(...processes.map((process2) => process2.prefix.length));
   function linePrefix(prefix, index) {
@@ -25249,7 +26223,7 @@ class AbortSilent extends Fatal {
 class Bug extends Fatal {
 }
 async function handler(error) {
-  const fatal = error instanceof Fatal ? error : new Fatal(error.message);
+  const fatal = error instanceof Fatal ? error : new Abort(error.message);
   await error$k(fatal);
   return Promise.resolve(error);
 }
@@ -39550,7 +40524,7 @@ class Body$1 {
 			return formData;
 		}
 
-		const {toFormData} = await import('./multipart-parser-95bacd77.js');
+		const {toFormData} = await import('./multipart-parser-b4090c19.js');
 		return toFormData(this.body, ct);
 	}
 
@@ -53478,33 +54452,136 @@ var github = /*#__PURE__*/Object.freeze({
 	parseRepoUrl: parseRepoUrl
 });
 
-var DependencyManager = /* @__PURE__ */ ((DependencyManager2) => {
-  DependencyManager2["Npm"] = "npm";
-  DependencyManager2["Yarn"] = "yarn";
-  DependencyManager2["Pnpm"] = "pnpm";
-  return DependencyManager2;
-})(DependencyManager || {});
-const dependencyManager = Object.entries(DependencyManager).map(([_, value]) => `${value}`);
+const dependencyManager = ["yarn", "npm", "pnpm"];
+const PackageJsonNotFoundError = (directory) => {
+  return new Bug(`The directory ${directory} doesn't have a package.json.`);
+};
 function dependencyManagerUsedForCreating(env = process.env) {
   if (env.npm_config_user_agent?.includes("yarn")) {
-    return "yarn" /* Yarn */;
+    return "yarn";
   } else if (env.npm_config_user_agent?.includes("pnpm")) {
-    return "pnpm" /* Pnpm */;
+    return "pnpm";
   } else {
-    return "npm" /* Npm */;
+    return "npm";
+  }
+}
+async function installNPMDependenciesRecursively(options) {
+  const packageJsons = await out(join$3(options.directory, "**/package.json"), {
+    ignore: [join$3(options.directory, "node_modules/**/package.json")],
+    cwd: options.directory,
+    onlyFiles: true,
+    deep: options.deep
+  });
+  const abortController = new AbortController$1();
+  try {
+    await Promise.all(packageJsons.map(async (packageJsonPath) => {
+      const directory = dirname$1(packageJsonPath);
+      await install(directory, options.dependencyManager, void 0, void 0, abortController.signal);
+    }));
+  } catch (error) {
+    abortController.abort();
+    throw error;
   }
 }
-async function install(directory, dependencyManager2, stdout, stderr) {
-  const options = { cwd: directory, stdout, stderr };
+async function install(directory, dependencyManager2, stdout, stderr, signal) {
+  const options = { cwd: directory, stdout, stderr, signal };
   await exec(dependencyManager2, ["install"], options);
 }
+async function getDependencies(packageJsonPath) {
+  if (!await exists$1(packageJsonPath)) {
+    throw PackageJsonNotFoundError(dirname$1(packageJsonPath));
+  }
+  const packageJsonContent = JSON.parse(await read(packageJsonPath));
+  const dependencies = packageJsonContent.dependencies ?? {};
+  const devDependencies = packageJsonContent.devDependencies ?? {};
+  return [...Object.keys(dependencies), ...Object.keys(devDependencies)];
+}
+async function addNPMDependenciesIfNeeded(dependencies, options) {
+  const packageJsonPath = join$3(options.directory, "package.json");
+  if (!await exists$1(packageJsonPath)) {
+    throw PackageJsonNotFoundError(options.directory);
+  }
+  const existingDependencies = await getDependencies(packageJsonPath);
+  const dependenciesToAdd = dependencies.filter((dep) => {
+    return !existingDependencies.includes(dep);
+  });
+  let args;
+  switch (options.dependencyManager) {
+    case "npm":
+      args = argumentsToAddDependenciesWithNPM(dependenciesToAdd, options.type);
+      break;
+    case "yarn":
+      args = argumentsToAddDependenciesWithYarn(dependenciesToAdd, options.type);
+      break;
+    case "pnpm":
+      args = argumentsToAddDependenciesWithPNPM(dependenciesToAdd, options.type);
+      break;
+  }
+  exec(options.dependencyManager, args, {
+    cwd: options.directory,
+    stdout: options.stdout,
+    stderr: options.stderr,
+    signal: options.signal
+  });
+}
+function argumentsToAddDependenciesWithNPM(dependencies, type) {
+  let command = ["install"];
+  command = command.concat(dependencies);
+  switch (type) {
+    case "dev":
+      command.push("--save-dev");
+      break;
+    case "peer":
+      command.push("--save-peer");
+      break;
+    case "prod":
+      command.push("--save-prod");
+      break;
+  }
+  return command;
+}
+function argumentsToAddDependenciesWithYarn(dependencies, type) {
+  let command = ["add"];
+  command = command.concat(dependencies);
+  switch (type) {
+    case "dev":
+      command.push("--dev");
+      break;
+    case "peer":
+      command.push("--peer");
+      break;
+    case "prod":
+      command.push("--prod");
+      break;
+  }
+  return command;
+}
+function argumentsToAddDependenciesWithPNPM(dependencies, type) {
+  let command = ["add"];
+  command = command.concat(dependencies);
+  switch (type) {
+    case "dev":
+      command.push("--save-dev");
+      break;
+    case "peer":
+      command.push("--save-peer");
+      break;
+    case "prod":
+      command.push("--save-prod");
+      break;
+  }
+  return command;
+}
 
 var dependency = /*#__PURE__*/Object.freeze({
 	__proto__: null,
-	DependencyManager: DependencyManager,
 	dependencyManager: dependencyManager,
+	PackageJsonNotFoundError: PackageJsonNotFoundError,
 	dependencyManagerUsedForCreating: dependencyManagerUsedForCreating,
-	install: install
+	installNPMDependenciesRecursively: installNPMDependenciesRecursively,
+	install: install,
+	getDependencies: getDependencies,
+	addNPMDependenciesIfNeeded: addNPMDependenciesIfNeeded
 });
 
 var packageJson$2 = {exports: {}};
@@ -170627,6 +171704,13 @@ function HeadersInstanceToPlainObject(headers) {
 }(dist$1));
 
 async function request$1(query, session, variables) {
+  debug$5(`
+Sending Admin GraphQL request:
+${query}
+
+With variables:
+${variables ? JSON.stringify(variables, null, 2) : ""}
+  `);
   const version = await fetchApiVersion(session);
   const url = adminUrl(session.storeFqdn, version);
   const headers = await buildHeaders(session.token);
@@ -170636,6 +171720,10 @@ async function fetchApiVersion(session) {
   const url = adminUrl(session.storeFqdn, "unstable");
   const query = apiVersionQuery();
   const headers = await buildHeaders(session.token);
+  debug$5(`
+Sending Admin GraphQL request to URL ${url} with query:
+${query}
+  `);
   const data = await dist$1.request(url, query, {}, headers);
   return data.publicApiVersions.filter((item) => item.supported).map((item) => item.handle).sort().reverse()[0];
 }
@@ -170663,6 +171751,13 @@ async function request(query, token, variables) {
   const fqdn = await partners$1();
   const url = `https://${fqdn}/api/cli/graphql`;
   const headers = await buildHeaders(token);
+  debug$5(`
+Sending Partners GraphQL request:
+${query}
+
+With variables:
+${variables ? JSON.stringify(variables, null, 2) : ""}
+  `);
   return dist$1.request(url, query, variables, headers);
 }
 
@@ -170678,16 +171773,6 @@ const FindOrganizationQuery = dist$1.gql`
         id
         businessName
         website
-        stores(first: 100) {
-          nodes {
-            shopId
-            link
-            shopDomain
-            shopName
-            transferDisabled
-            convertableToPartnerTest
-          }
-        }
         apps(first: 100) {
           nodes {
             id
@@ -170717,16 +171802,8 @@ const AllOrganizationsQuery = dist$1.gql`
 `;
 
 const CreateAppQuery = dist$1.gql`
-  mutation AppCreate($org: Int!, $title: String!, $appUrl: Url!, $redir: [Url]!, $type: AppType) {
-    appCreate(
-      input: {
-        organizationID: $org
-        title: $title
-        applicationUrl: $appUrl
-        redirectUrlWhitelist: $redir
-        appType: $type
-      }
-    ) {
+  mutation AppCreate($org: Int!, $title: String!, $appUrl: Url!, $redir: [Url]!) {
+    appCreate(input: {organizationID: $org, title: $title, applicationUrl: $appUrl, redirectUrlWhitelist: $redir}) {
       app {
         id
         apiKey
@@ -170822,6 +171899,38 @@ const CreateDeployment = dist$1.gql`
   }
 `;
 
+const AllStoresByOrganizationQuery = dist$1.gql`
+  query FindOrganization($id: ID!) {
+    organizations(id: $id, first: 1) {
+      nodes {
+        id
+        stores(first: 500) {
+          nodes {
+            shopId
+            link
+            shopDomain
+            shopName
+            transferDisabled
+            convertableToPartnerTest
+          }
+        }
+      }
+    }
+  }
+`;
+
+const ConvertDevToTestStoreQuery = dist$1.gql`
+  mutation convertDevToTestStore($input: ConvertDevToTestStoreInput!) {
+    convertDevToTestStore(input: $input) {
+      convertedToTestStore
+      userErrors {
+        message
+        field
+      }
+    }
+  }
+`;
+
 var index = /*#__PURE__*/Object.freeze({
 	__proto__: null,
 	FindOrganizationQuery: FindOrganizationQuery,
@@ -170831,7 +171940,9 @@ var index = /*#__PURE__*/Object.freeze({
 	FindAppQuery: FindAppQuery,
 	UpdateDraftMutation: UpdateDraftMutation,
 	GenerateSignedUploadUrl: GenerateSignedUploadUrl,
-	CreateDeployment: CreateDeployment
+	CreateDeployment: CreateDeployment,
+	AllStoresByOrganizationQuery: AllStoresByOrganizationQuery,
+	ConvertDevToTestStoreQuery: ConvertDevToTestStoreQuery
 });
 
 var api = /*#__PURE__*/Object.freeze({
@@ -171124,12 +172235,12 @@ async function validateRubyEnv() {
   try {
     await exec("ruby", ["-v"]);
   } catch {
-    throw new Fatal("Ruby environment not found", "Make sure you have ruby installed on your system: https://www.ruby-lang.org/en/documentation/installation/");
+    throw new Abort("Ruby environment not found", "Make sure you have ruby installed on your system: https://www.ruby-lang.org/en/documentation/installation/");
   }
   const bundlerVersion = await getBundlerVersion();
   const isValid = bundlerVersion?.compare(MinBundlerVersion);
   if (isValid === -1 || isValid === void 0) {
-    throw new Fatal(`Bundler version ${bundlerVersion} is not supported`, `Make sure you have Bundler version ${MinBundlerVersion} or higher installed on your system: https://bundler.io/`);
+    throw new Abort(`Bundler version ${bundlerVersion} is not supported`, `Make sure you have Bundler version ${MinBundlerVersion} or higher installed on your system: https://bundler.io/`);
   }
 }
 async function getBundlerVersion() {
@@ -171137,7 +172248,7 @@ async function getBundlerVersion() {
     const { stdout } = await exec("bundler", ["-v"]);
     return coerce_1(stdout);
   } catch {
-    throw new Fatal("Bundler not found", "Make sure you have Bundler installed on your system: https://bundler.io/");
+    throw new Abort("Bundler not found", "Make sure you have Bundler installed on your system: https://bundler.io/");
   }
 }
 function createWorkingDirectory() {
@@ -171437,4 +172548,4 @@ var plugins = /*#__PURE__*/Object.freeze({
 });
 
 export { npm as A, port as B, cli as C, id as D, temporary as E, FormData$3 as F, constants$2 as G, plugins as H, File$1 as a, string as b, github as c, dependency as d, error$j as e, file$1 as f, git as g, os$2 as h, environment as i, session as j, schema$2 as k, toml as l, store as m, api as n, output as o, path$w as p, http$2 as q, archiver as r, system as s, template as t, ui as u, version as v, checksum as w, ruby as x, yaml as y, semver as z };
-//# sourceMappingURL=index-0f69cf26.js.map
+//# sourceMappingURL=index-cee0245d.js.map