@wix/cli/build/ReleaseCommand-B4LVYLQH.js

CLI tool for building Wix sites and applications

import { createRequire as _createRequire } from 'node:module';
const require = _createRequire(import.meta.url);
import {
  useWixCliAppBi
} from "./chunk-CKNVM7JY.js";
import {
  ActionStatus,
  PreviewCommand,
  useCreatePreview
} from "./chunk-FCDJ4VXU.js";
import {
  useDevCenterOverridesClient,
  useUpdateDeploymentTopologyForSite
} from "./chunk-EA4ZV7ZO.js";
import {
  assertBuildOutputExists
} from "./chunk-NPYBTUWU.js";
import "./chunk-BUPV3T3K.js";
import "./chunk-ZJ4HTMFG.js";
import "./chunk-DGC6KEUB.js";
import "./chunk-QRGKMYDD.js";
import "./chunk-CKNI3TGO.js";
import "./chunk-YLCFL3QA.js";
import {
  ComponentType
} from "./chunk-BHWSM372.js";
import {
  useBackendAsAServiceClient
} from "./chunk-JQOAY3IH.js";
import "./chunk-7QJUAJW3.js";
import "./chunk-NMCF7XG5.js";
import "./chunk-MHV22UIU.js";
import {
  useProjectModel,
  useSiteConfig
} from "./chunk-OQJA5FSX.js";
import "./chunk-AAUVYJJT.js";
import "./chunk-K6JLY75P.js";
import "./chunk-KCDAY54L.js";
import {
  useHttpClient
} from "./chunk-FYLO6WOU.js";
import {
  usePanoramaMethodLogger
} from "./chunk-3B6VL2WO.js";
import {
  require_isArray
} from "./chunk-7QTVQZAE.js";
import {
  SiteAuthProvider,
  isHttpError,
  isHttpValidationError,
  pRetry,
  require_semver,
  resolveUrl,
  serializer
} from "./chunk-CCWE4DS6.js";
import "./chunk-U5H3SP3I.js";
import "./chunk-TIVTYCB2.js";
import "./chunk-RPTAJN5Y.js";
import {
  Alert,
  Box_default,
  Cart,
  ConfirmInput,
  Link,
  Notification,
  SelectInput,
  SelectOptionAvailability,
  Spinner,
  Statistics,
  Text,
  TextInput,
  useAsync,
  useAsyncCallback
} from "./chunk-UC5LTXTA.js";
import {
  require_baseGetTag,
  require_isObjectLike
} from "./chunk-5VIJC5EU.js";
import "./chunk-MZDJNQLB.js";
import {
  require_react
} from "./chunk-QNHANFRW.js";
import "./chunk-AFPDHQYI.js";
import "./chunk-HYKBBZLS.js";
import "./chunk-C5RTKQVL.js";
import "./chunk-4EJ5VQTT.js";
import "./chunk-4UTFAKA5.js";
import "./chunk-LU3R3EBR.js";
import {
  getTestOverrides
} from "./chunk-XZUGLEBK.js";
import "./chunk-TLLAD5LU.js";
import {
  external_exports
} from "./chunk-SDLCFZRL.js";
import {
  CliError,
  CliErrorCode,
  require_lib
} from "./chunk-CO5A7CZG.js";
import {
  __commonJS,
  __toESM,
  init_esm_shims
} from "./chunk-EXLZF52D.js";

// ../../node_modules/lodash/isString.js
var require_isString = __commonJS({
  "../../node_modules/lodash/isString.js"(exports, module) {
    "use strict";
    init_esm_shims();
    var baseGetTag = require_baseGetTag();
    var isArray = require_isArray();
    var isObjectLike = require_isObjectLike();
    var stringTag = "[object String]";
    function isString2(value) {
      return typeof value == "string" || !isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
    }
    module.exports = isString2;
  }
});

// ../cli-astro-commands/src/components/ReleaseCommand/index.ts
init_esm_shims();

// ../cli-astro-commands/src/components/ReleaseCommand/ReleaseCommand.tsx
init_esm_shims();
var import_react10 = __toESM(require_react(), 1);
var import_variant4 = __toESM(require_lib(), 1);

// ../cli-astro-commands/src/components/ReleaseCommand/ReleaseSite.tsx
init_esm_shims();
var import_react2 = __toESM(require_react(), 1);
var import_variant2 = __toESM(require_lib(), 1);

// ../arm-client/src/index.ts
init_esm_shims();

// ../arm-client/src/client.ts
init_esm_shims();

// ../../node_modules/@wix/ambassador-ctp-gradual-rollout-v1-app-config/build/es/http.impl.js
init_esm_shims();
var _commitComponentOverrideRequest = {};
var _commitComponentOverrideResponse = {};
var _createAppReleaseRequest = {};
var _createAppReleaseResponse = {};
var _createComponentsRequest = {};
var _createComponentsResponse = {};
var _promoteAppVersionFromDraftToProductionRequest = {};
var _promoteAppVersionFromDraftToProductionResponse = {};
var _updateAppReleaseRequest = {};
var _updateAppReleaseResponse = {};
function resolveComWixCtpAppsReleaseManagerServiceUrl(opts) {
  var domainToMappings = {
    "api._api_base_domain_": [
      {
        srcPath: "/apps-release-manager-service-web",
        destPath: ""
      }
    ],
    "bo._base_domain_": [
      {
        srcPath: "/apps-release-manager-service-web",
        destPath: ""
      }
    ],
    "wixbo.ai": [
      {
        srcPath: "/apps-release-manager-service-web",
        destPath: ""
      }
    ],
    "wix-bo.com": [
      {
        srcPath: "/apps-release-manager-service-web",
        destPath: ""
      }
    ],
    "www._base_domain_": [
      {
        srcPath: "/apps-release-manager-service-web/artifacts-release-manager/app-releases",
        destPath: "/artifacts-release-manager/app-releases"
      },
      {
        srcPath: "/_api/apps-release-manager-service-web/artifacts-release-manager/app-releases",
        destPath: "/artifacts-release-manager/app-releases"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/create",
        destPath: "/apps/create"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/promote",
        destPath: "/apps/promote"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/tags",
        destPath: "/apps/tags"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/create-components",
        destPath: "/apps/create-components"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/commit",
        destPath: "/apps/commit"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/promote-app-version",
        destPath: "/apps/promote-app-version"
      }
    ],
    "manage._base_domain_": [
      {
        srcPath: "/apps-release-manager-service-web/apps/promote",
        destPath: "/apps/promote"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/create",
        destPath: "/apps/create"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/tags",
        destPath: "/apps/tags"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/create-components",
        destPath: "/apps/create-components"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/commit",
        destPath: "/apps/commit"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/promote-app-version",
        destPath: "/apps/promote-app-version"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/release",
        destPath: "/apps/release"
      }
    ]
  };
  return resolveUrl(Object.assign(opts, { domainToMappings }));
}
function createAppRelease(payload) {
  var _a = serializer(_createAppReleaseRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_createAppReleaseResponse, {}).fromJSON;
  function __createAppRelease(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.ctp.gradual_rollout.v1.app_config",
      method: "POST",
      methodFqn: "com.wix.ctp.AppsReleaseManagerService.CreateAppRelease",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveComWixCtpAppsReleaseManagerServiceUrl({
        protoPath: "/apps/create/{appId}",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __createAppRelease.fromReq = fromReq;
  __createAppRelease.__isAmbassador = true;
  return __createAppRelease;
}
function updateAppRelease(payload) {
  var _a = serializer(_updateAppReleaseRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_updateAppReleaseResponse, {}).fromJSON;
  function __updateAppRelease(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.ctp.gradual_rollout.v1.app_config",
      method: "PUT",
      methodFqn: "com.wix.ctp.AppsReleaseManagerService.UpdateAppRelease",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveComWixCtpAppsReleaseManagerServiceUrl({
        protoPath: "/apps/tags/{tag}",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __updateAppRelease.fromReq = fromReq;
  __updateAppRelease.__isAmbassador = true;
  return __updateAppRelease;
}
function createComponents(payload) {
  var _a = serializer(_createComponentsRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_createComponentsResponse, {}).fromJSON;
  function __createComponents(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.ctp.gradual_rollout.v1.app_config",
      method: "POST",
      methodFqn: "com.wix.ctp.AppsReleaseManagerService.CreateComponents",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveComWixCtpAppsReleaseManagerServiceUrl({
        protoPath: "/apps/create-components/{appId}",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __createComponents.fromReq = fromReq;
  __createComponents.__isAmbassador = true;
  return __createComponents;
}
function commitComponentOverride(payload) {
  var _a = serializer(_commitComponentOverrideRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_commitComponentOverrideResponse, {}).fromJSON;
  function __commitComponentOverride(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.ctp.gradual_rollout.v1.app_config",
      method: "POST",
      methodFqn: "com.wix.ctp.AppsReleaseManagerService.CommitComponentOverride",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveComWixCtpAppsReleaseManagerServiceUrl({
        protoPath: "/apps/commit/{appId}/{componentOverrideId}",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __commitComponentOverride.fromReq = fromReq;
  __commitComponentOverride.__isAmbassador = true;
  return __commitComponentOverride;
}
function promoteAppVersionFromDraftToProduction(payload) {
  var _a = serializer(_promoteAppVersionFromDraftToProductionRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_promoteAppVersionFromDraftToProductionResponse, {}).fromJSON;
  function __promoteAppVersionFromDraftToProduction(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.ctp.gradual_rollout.v1.app_config",
      method: "POST",
      methodFqn: "com.wix.ctp.AppsReleaseManagerService.PromoteAppVersionFromDraftToProduction",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveComWixCtpAppsReleaseManagerServiceUrl({
        protoPath: "/apps/promote-app-version/{appId}/{createNewMajor}/{latestMajor}",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __promoteAppVersionFromDraftToProduction.fromReq = fromReq;
  __promoteAppVersionFromDraftToProduction.__isAmbassador = true;
  return __promoteAppVersionFromDraftToProduction;
}

// ../../node_modules/@wix/ambassador-ctp-gradual-rollout-v1-baas-release/es/build/http.impl.js
init_esm_shims();
var _releaseRequest = {};
var _releaseResponse = {};
function resolveComWixCtpAppsReleaseManagerBassServiceUrl(opts) {
  var domainToMappings = {
    "api._api_base_domain_": [
      {
        srcPath: "/apps-release-manager-service-web",
        destPath: ""
      }
    ],
    "bo._base_domain_": [
      {
        srcPath: "/apps-release-manager-service-web",
        destPath: ""
      }
    ],
    "wixbo.ai": [
      {
        srcPath: "/apps-release-manager-service-web",
        destPath: ""
      }
    ],
    "wix-bo.com": [
      {
        srcPath: "/apps-release-manager-service-web",
        destPath: ""
      }
    ],
    "www._base_domain_": [
      {
        srcPath: "/apps-release-manager-service-web/artifacts-release-manager/app-releases",
        destPath: "/artifacts-release-manager/app-releases"
      },
      {
        srcPath: "/_api/apps-release-manager-service-web/artifacts-release-manager/app-releases",
        destPath: "/artifacts-release-manager/app-releases"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/create",
        destPath: "/apps/create"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/promote",
        destPath: "/apps/promote"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/tags",
        destPath: "/apps/tags"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/create-components",
        destPath: "/apps/create-components"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/commit",
        destPath: "/apps/commit"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/promote-app-version",
        destPath: "/apps/promote-app-version"
      }
    ],
    "manage._base_domain_": [
      {
        srcPath: "/apps-release-manager-service-web/apps/promote",
        destPath: "/apps/promote"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/create",
        destPath: "/apps/create"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/tags",
        destPath: "/apps/tags"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/create-components",
        destPath: "/apps/create-components"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/commit",
        destPath: "/apps/commit"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/promote-app-version",
        destPath: "/apps/promote-app-version"
      },
      {
        srcPath: "/apps-release-manager-service-web/apps/release",
        destPath: "/apps/release"
      }
    ]
  };
  return resolveUrl(Object.assign(opts, { domainToMappings }));
}
function release(payload) {
  var _a = serializer(_releaseRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_releaseResponse, {}).fromJSON;
  function __release(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.ctp.gradual_rollout.v1.baas_release",
      method: "POST",
      methodFqn: "com.wix.ctp.AppsReleaseManagerBassService.Release",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveComWixCtpAppsReleaseManagerBassServiceUrl({
        protoPath: "/apps/release/{appId}/{componentOverrideId}",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __release.fromReq = fromReq;
  __release.__isAmbassador = true;
  return __release;
}

// ../arm-client/src/client.ts
var import_variant = __toESM(require_lib(), 1);

// ../arm-client/src/isTrustedInternalErr.ts
init_esm_shims();
function isTrustedInternalErr(e) {
  if (isHttpError(e)) {
    const appError = e.response?.data?.details?.applicationError;
    if (appError?.description) {
      let errDescription;
      try {
        errDescription = JSON.parse(appError.description);
      } catch {
      }
      return errDescription?.results?.some(
        (result) => result.error?.startsWith("scriptAsset is not supported")
      );
    }
  }
  return false;
}

// ../arm-client/src/schemas.ts
init_esm_shims();
var promoteAppVersionFromDraftToProductionSchema = external_exports.object({
  fullVersion: external_exports.string()
});
var commitComponentOverrideSchema = external_exports.object({
  nextMajor: external_exports.string(),
  nextMinor: external_exports.string().optional()
});
var createAppReleaseSchema = external_exports.object({
  tag: external_exports.string()
});
var releaseSchema = external_exports.object({
  releaseBaseUrl: external_exports.string()
});

// ../arm-client/src/client.ts
var { AppPermissionDenied } = CliErrorCode;
var UpdateAppReleaseData = (0, import_variant.variant)({
  TagNotFound: (0, import_variant.fields)(),
  TagUpdated: {}
});
var ARMClient = class {
  constructor(httpClient) {
    this.httpClient = httpClient;
    const { minRetryTimeout, retries } = getTestOverrides();
    this.retryOptions = {
      maxTimeout: 3 * 1e3,
      minTimeout: minRetryTimeout,
      retries: retries ?? 3
    };
  }
  retryOptions;
  createComponents = async (appId, componentConfigs, projectId) => {
    try {
      await this.httpClient.request(
        createComponents({ appId, componentConfigs, projectId })
      );
    } catch (e) {
      if (isHttpError(e) && e.response?.status === 403) {
        throw new CliError({
          cause: e,
          code: AppPermissionDenied({ appId })
        });
      }
      throw new CliError({
        cause: e,
        code: CliErrorCode.FailedToCreateComponents()
      });
    }
  };
  createAppRelease = async (manifest, projectId) => {
    try {
      const { data } = await pRetry(
        () => this.httpClient.request(
          createAppRelease({
            appId: manifest.appId,
            componentConfigs: manifest.components,
            projectId
          })
        ),
        this.retryOptions
      );
      return createAppReleaseSchema.parse(data).tag;
    } catch (e) {
      if (isHttpError(e)) {
        if (e.response?.status === 403) {
          throw new CliError({
            cause: e,
            code: AppPermissionDenied({ appId: manifest.appId })
          });
        }
        if (e.response?.status === 400 && isHttpValidationError(e)) {
          throw new CliError({
            cause: e,
            code: CliErrorCode.AppReleaseConfigViolations()
          });
        }
      }
      if (isTrustedInternalErr(e)) {
        throw new CliError({
          cause: e,
          code: CliErrorCode.TrustedAppIsNotMarkedAsInternal()
        });
      }
      throw new CliError({
        cause: e,
        code: CliErrorCode.FailedToCreateAppRelease()
      });
    }
  };
  updateAppRelease = async (manifest, tag) => {
    try {
      await pRetry(
        () => this.httpClient.request(
          updateAppRelease({
            appId: manifest.appId,
            componentConfigs: manifest.components,
            tag
          })
        ),
        this.retryOptions
      );
      return UpdateAppReleaseData.TagUpdated();
    } catch (e) {
      if (isHttpError(e)) {
        if (e.response?.status === 404) {
          return UpdateAppReleaseData.TagNotFound({ cause: e });
        }
        if (e.response?.status === 403) {
          throw new CliError({
            cause: e,
            code: AppPermissionDenied({ appId: manifest.appId })
          });
        }
        if (e.response?.status === 400 && isHttpValidationError(e)) {
          throw new CliError({
            cause: e,
            code: CliErrorCode.AppReleaseConfigViolations()
          });
        }
      }
      if (isTrustedInternalErr(e)) {
        throw new CliError({
          cause: e,
          code: CliErrorCode.TrustedAppIsNotMarkedAsInternal()
        });
      }
      throw new CliError({
        cause: e,
        code: CliErrorCode.FailedToUpdateAppRelease()
      });
    }
  };
  createDraftVersion = async (appId, tag) => {
    try {
      const { data } = await this.httpClient.request(
        commitComponentOverride({
          appId,
          componentOverrideId: tag
        })
      );
      return commitComponentOverrideSchema.parse(data);
    } catch (cause) {
      throw new CliError({
        cause,
        code: CliErrorCode.FailedToCreateDraftVersion()
      });
    }
  };
  releaseDraftVersion = async (appId, options) => {
    try {
      const { data } = await this.httpClient.request(
        promoteAppVersionFromDraftToProduction({
          appId,
          createNewMajor: options.createNewMajor,
          latestMajor: options.latestMajor,
          notes: options.notes
        })
      );
      const { fullVersion } = promoteAppVersionFromDraftToProductionSchema.parse(data);
      return { releasedVersion: fullVersion };
    } catch (cause) {
      throw new CliError({
        cause,
        code: CliErrorCode.FailedToReleaseDraftVersion()
      });
    }
  };
  releaseHeadlessProject = async ({
    appId,
    comment,
    componentOverrideId,
    createMinorVersion
  }) => {
    try {
      const { data } = await this.httpClient.request(
        release({
          appId,
          componentOverrideId,
          createMinorVersion,
          notes: comment
        })
      );
      return releaseSchema.parse(data).releaseBaseUrl;
    } catch (e) {
      throw new CliError({
        cause: e,
        code: CliErrorCode.FailedToReleaseHeadlessProject()
      });
    }
  };
};

// ../arm-client/src/useARMClient.ts
init_esm_shims();
var import_react = __toESM(require_react(), 1);
function useARMClient() {
  const httpClient = useHttpClient({ type: "backoffice" });
  const client = (0, import_react.useMemo)(() => new ARMClient(httpClient), [httpClient]);
  return usePanoramaMethodLogger(client);
}

// ../cli-astro-commands/src/components/ReleaseCommand/ReleaseSite.tsx
var ReleaseSite = ({
  baseUrl,
  label,
  createMinorVersion,
  comment
}) => {
  const { appId, siteId } = useSiteConfig();
  const { getAppProject } = useBackendAsAServiceClient();
  const { releaseHeadlessProject } = useARMClient();
  const updateDeploymentTopology = useUpdateDeploymentTopologyForSite(siteId);
  const releaseAction = useAsyncCallback(
    async (_, previewId, previewUrl) => {
      const deploymentBaseUrl = await releaseHeadlessProject({
        appId,
        componentOverrideId: previewId,
        createMinorVersion,
        comment
      });
      await updateDeploymentTopology({
        environment: "production",
        siteUrl: previewUrl ?? "",
        versionOverrideId: previewId
      });
      const appProject = await getAppProject(appId);
      return { baseUrl: appProject?.customDomain?.domain ?? deploymentBaseUrl };
    }
  );
  const { uploadStatus } = useCreatePreview({
    baseUrl,
    label,
    onPreviewCreated: ({ previewId, previewUrl }) => {
      void releaseAction.execute(previewId, previewUrl);
    }
  });
  return /* @__PURE__ */ import_react2.default.createElement(import_react2.default.Fragment, null, /* @__PURE__ */ import_react2.default.createElement(
    ActionStatus,
    {
      status: uploadStatus,
      loadingText: "Uploading your application files...",
      successText: "Uploaded successfully!"
    }
  ), (0, import_variant2.match)(releaseAction.status, {
    NotRequested: () => null,
    Error: () => null,
    Loading: () => /* @__PURE__ */ import_react2.default.createElement(Spinner, { text: /* @__PURE__ */ import_react2.default.createElement(Text, null, "Releasing...") }),
    Success: ({ result: { baseUrl: baseUrl2 } }) => /* @__PURE__ */ import_react2.default.createElement(Box_default, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ import_react2.default.createElement(Alert, { type: "success" }, /* @__PURE__ */ import_react2.default.createElement(Text, { bold: true }, "Site published on ", baseUrl2)))
  }));
};

// ../cli-astro-commands/src/components/ReleaseCommand/app-flow/ReleaseApp.tsx
init_esm_shims();
var import_react9 = __toESM(require_react(), 1);
var import_isString = __toESM(require_isString(), 1);
var import_semver = __toESM(require_semver(), 1);
var import_variant3 = __toESM(require_lib(), 1);

// ../cli-astro-commands/src/components/ReleaseCommand/Steps/CreatePreview.tsx
init_esm_shims();
var import_react3 = __toESM(require_react(), 1);
var CreatePreview = (props) => {
  const { baseUrl, label, onCreated } = props;
  return /* @__PURE__ */ import_react3.default.createElement(Box_default, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ import_react3.default.createElement(Text, null, "Before creating a new version, let's create a preview of your app"), /* @__PURE__ */ import_react3.default.createElement(Box_default, { flexDirection: "column" }, /* @__PURE__ */ import_react3.default.createElement(
    PreviewCommand,
    {
      baseUrl,
      label,
      onPreviewCreated: onCreated,
      environment: "production"
    }
  )));
};

// ../cli-astro-commands/src/components/ReleaseCommand/app-flow/Warnings.tsx
init_esm_shims();
var import_react4 = __toESM(require_react(), 1);
var Warnings = ({
  components
}) => {
  if (components.filter((c) => c.compType === ComponentType.WEBHOOK).length === 0) {
    return null;
  }
  return /* @__PURE__ */ import_react4.default.createElement(Box_default, { flexDirection: "column", paddingBottom: 1 }, /* @__PURE__ */ import_react4.default.createElement(Notification, null, /* @__PURE__ */ import_react4.default.createElement(Alert, { type: "warning" }, "Your project includes backend events. Once you continue, any changes to events will be immediately deployed to production and take effect automatically, even without a new version release.")));
};

// ../cli-astro-commands/src/components/ReleaseCommand/app-flow/ReleaseComment.tsx
init_esm_shims();
var import_react5 = __toESM(require_react(), 1);
var ReleaseComment = (props) => {
  const { onEntered } = props;
  const bi = useWixCliAppBi();
  const validate = (0, import_react5.useCallback)((value) => {
    if (value && value.length > 250) {
      return "The comment is limited to a maximum of 250 characters";
    }
    return true;
  }, []);
  const question = "Enter a comment describing any changes made to this version. This won't be shown to users (optional)";
  return /* @__PURE__ */ import_react5.default.createElement(
    TextInput,
    {
      label: question,
      onSubmit: (answer) => {
        bi.cliFlowStepAnswered({
          question,
          questionKey: "release_command.enter_release_comment",
          answer
        });
        onEntered(answer);
      },
      validate
    }
  );
};

// ../cli-astro-commands/src/components/ReleaseCommand/app-flow/ConfirmMinorVersion.tsx
init_esm_shims();
var import_react6 = __toESM(require_react(), 1);
var ConfirmMinorVersion = (props) => {
  const { onConfirmed } = props;
  const bi = useWixCliAppBi();
  const question = "Changes will be visible to your app users immediately and can\u2019t be undone. Do you want to continue?";
  return /* @__PURE__ */ import_react6.default.createElement(Box_default, { flexDirection: "column", paddingBottom: 1 }, /* @__PURE__ */ import_react6.default.createElement(
    ConfirmInput,
    {
      label: question,
      initialValue: true,
      onSubmit: (confirm) => {
        bi.cliFlowStepAnswered({
          question,
          questionKey: "release_command.confirm_version_creation",
          answer: String(confirm)
        });
        if (confirm) {
          onConfirmed();
        }
      }
    }
  ));
};

// ../cli-astro-commands/src/components/ReleaseCommand/app-flow/ChooseVersion.tsx
init_esm_shims();
var import_react7 = __toESM(require_react(), 1);
var ChooseVersion = (props) => {
  const { nextMinor, nextMajor, onChosen } = props;
  const bi = useWixCliAppBi();
  const options = [
    {
      title: nextMinor ? `Minor (${nextMinor})` : "Minor",
      description: "update doesn\u2019t require Wix user consent",
      value: "MINOR" /* MINOR */,
      availability: nextMinor ? SelectOptionAvailability.Enabled() : SelectOptionAvailability.Disabled({
        reason: /* @__PURE__ */ import_react7.default.createElement(Text, null, "Recent changes you made require this release to be a major release. ", /* @__PURE__ */ import_react7.default.createElement(Link, { url: "https://wix.to/ZR80Y7p" }, "Learn more"))
      })
    },
    {
      title: `Major (${nextMajor})`,
      description: "update requires Wix user consent",
      value: "MAJOR" /* MAJOR */
    }
  ];
  const question = "What type of version would you like to create?";
  return /* @__PURE__ */ import_react7.default.createElement(
    SelectInput,
    {
      label: question,
      options,
      initialIndex: nextMinor ? 0 : 1,
      onSubmit: ({ value }) => {
        bi.cliFlowStepAnswered({
          question,
          questionKey: "release_command.version_type_question",
          answer: value
        });
        onChosen(value);
      }
    }
  );
};

// ../cli-astro-commands/src/components/ReleaseCommand/app-flow/NextSteps.tsx
init_esm_shims();
var import_react8 = __toESM(require_react(), 1);
var NextSteps = () => {
  const {
    model: {
      config: { appId }
    }
  } = useProjectModel();
  const homeUrl = `https://dev.wix.com/apps/${appId}/home?referralInfo=wix-cli`;
  const statisticsUrl = `https://dev.wix.com/apps/${appId}/statistics?referralInfo=wix-cli`;
  return /* @__PURE__ */ import_react8.default.createElement(Box_default, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ import_react8.default.createElement(Text, { bold: true }, "Next Steps:"), /* @__PURE__ */ import_react8.default.createElement(Text, null, /* @__PURE__ */ import_react8.default.createElement(Statistics, null), " View your app reviews and statistics in the", " ", /* @__PURE__ */ import_react8.default.createElement(Link, { url: statisticsUrl }, "app dashboard")), /* @__PURE__ */ import_react8.default.createElement(Text, null, /* @__PURE__ */ import_react8.default.createElement(Cart, null), " Select your distribution method from the", " ", /* @__PURE__ */ import_react8.default.createElement(Link, { url: homeUrl }, "app dashboard")));
};

// ../cli-astro-commands/src/components/ReleaseCommand/app-flow/ReleaseApp.tsx
var ReleaseApp = ({
  baseUrl,
  label,
  preEnteredComment,
  preSelectedVersionType
}) => {
  const {
    model: {
      config: { appId }
    }
  } = useProjectModel();
  const { createDraftVersion, releaseDraftVersion } = useDevCenterOverridesClient();
  const [preview, setPreview] = (0, import_react9.useState)();
  const [comment, setComment] = (0, import_react9.useState)();
  const [versionType, setVersionType] = (0, import_react9.useState)();
  const [userShouldSelectVersion, setUserShouldSelectVersion] = (0, import_react9.useState)(false);
  const createDraftAction = useAsyncCallback(async (_, previewId) => {
    const { nextMajor, nextMinor } = await createDraftVersion(appId, previewId);
    const appWasNeverReleased = nextMajor === "1.0.0" && !nextMinor;
    const parsedNextMajor = (0, import_semver.parse)(nextMajor);
    if (parsedNextMajor == null) {
      throw new CliError({
        code: CliErrorCode.FailedToParseNextVersion({ version: nextMajor }),
        cause: void 0
      });
    }
    return {
      nextMinor,
      nextMajor,
      appWasNeverReleased,
      latestMajor: parsedNextMajor.major - 1
    };
  });
  const releaseDraftAction = useAsyncCallback(
    async (_, versionType2, comment2, latestMajor) => {
      const result = await releaseDraftVersion(appId, {
        createNewMajor: versionType2 === "MAJOR" /* MAJOR */,
        notes: comment2,
        latestMajor
      });
      return result;
    }
  );
  async function onReleaseCommentEntered({
    previewId,
    comment: comment2
  }) {
    setComment(comment2);
    const result = await createDraftAction.execute(previewId).catch(() => null);
    if (!result) {
      return;
    }
    const { appWasNeverReleased, nextMinor, latestMajor } = result;
    const chosenVersion = appWasNeverReleased ? "MAJOR" /* MAJOR */ : preSelectedVersionType;
    if (preSelectedVersionType === "MINOR" /* MINOR */ && (appWasNeverReleased || !nextMinor)) {
      throw new CliError({
        cause: null,
        code: CliErrorCode.CannotReleaseMinorInNoninteractive()
      });
    }
    if (chosenVersion) {
      void releaseDraftAction.execute(chosenVersion, comment2, latestMajor);
    } else {
      setUserShouldSelectVersion(true);
    }
  }
  return /* @__PURE__ */ import_react9.default.createElement(import_react9.default.Fragment, null, /* @__PURE__ */ import_react9.default.createElement(
    CreatePreview,
    {
      baseUrl,
      label,
      onCreated: (result) => {
        setPreview(result);
        if ((0, import_isString.default)(preEnteredComment)) {
          void onReleaseCommentEntered({
            previewId: result.previewId,
            comment: preEnteredComment
          });
        }
      }
    }
  ), preview && /* @__PURE__ */ import_react9.default.createElement(Warnings, { components: preview.appManifest.components }), preview && !(0, import_isString.default)(preEnteredComment) && /* @__PURE__ */ import_react9.default.createElement(
    ReleaseComment,
    {
      onEntered: (comment2) => onReleaseCommentEntered({
        previewId: preview.previewId,
        comment: comment2
      })
    }
  ), (0, import_isString.default)(comment) && (0, import_variant3.match)(createDraftAction.status, {
    NotRequested: () => null,
    Error: () => null,
    Loading: () => /* @__PURE__ */ import_react9.default.createElement(Spinner, { text: "Updating draft application version" }),
    Success: ({ result: { nextMajor, nextMinor, latestMajor } }) => /* @__PURE__ */ import_react9.default.createElement(import_react9.default.Fragment, null, userShouldSelectVersion && /* @__PURE__ */ import_react9.default.createElement(
      ChooseVersion,
      {
        nextMinor,
        nextMajor,
        onChosen: (selectedVersionType) => {
          setVersionType(selectedVersionType);
          if (selectedVersionType === "MAJOR" /* MAJOR */) {
            void releaseDraftAction.execute(
              selectedVersionType,
              comment,
              latestMajor
            );
          }
        }
      }
    ), versionType === "MINOR" /* MINOR */ && /* @__PURE__ */ import_react9.default.createElement(
      ConfirmMinorVersion,
      {
        onConfirmed: () => releaseDraftAction.execute(
          versionType,
          comment,
          latestMajor
        )
      }
    ))
  }), (0, import_variant3.match)(releaseDraftAction.status, {
    NotRequested: () => null,
    Error: () => null,
    Loading: () => /* @__PURE__ */ import_react9.default.createElement(Spinner, { text: "Releasing..." }),
    Success: ({ result: { releasedVersion } }) => /* @__PURE__ */ import_react9.default.createElement(Box_default, { flexDirection: "column", gap: 1 }, /* @__PURE__ */ import_react9.default.createElement(Alert, { type: "success" }, /* @__PURE__ */ import_react9.default.createElement(Text, { bold: true }, "Version ", releasedVersion, " was created")), /* @__PURE__ */ import_react9.default.createElement(NextSteps, null))
  }));
};

// ../cli-astro-commands/src/components/ReleaseCommand/ReleaseCommand.tsx
var ReleaseCommand = (props) => {
  const {
    model: { projectFolder, config }
  } = useProjectModel();
  const { status } = useAsync(async () => {
    await assertBuildOutputExists(projectFolder, config);
  }, []);
  return (0, import_variant4.match)(status, {
    Error: () => null,
    Loading: () => /* @__PURE__ */ import_react10.default.createElement(Spinner, { text: /* @__PURE__ */ import_react10.default.createElement(Text, null, "Loading application details...") }),
    Success: () => {
      return config.projectType === "Site" ? /* @__PURE__ */ import_react10.default.createElement(SiteAuthProvider, { siteId: config.siteId }, /* @__PURE__ */ import_react10.default.createElement(
        ReleaseSite,
        {
          ...props,
          createMinorVersion: props.versionType === "MINOR" /* MINOR */
        }
      )) : /* @__PURE__ */ import_react10.default.createElement(
        ReleaseApp,
        {
          baseUrl: props.baseUrl,
          label: props.label,
          preEnteredComment: props.comment,
          preSelectedVersionType: props.versionType
        }
      );
    }
  });
};
export {
  ReleaseCommand
};
//# sourceMappingURL=ReleaseCommand-B4LVYLQH.js.map