@wix/cli/build/chunk-C4EZJBTU.js

CLI tool for building Wix sites and applications

import { createRequire as _createRequire } from 'node:module';
const require = _createRequire(import.meta.url);
import {
  useHttpClient
} from "./chunk-NPIBHDAX.js";
import {
  BACKEND_WORKER_COMPONENT_ID,
  ComponentType,
  deploymentTopologySchema,
  getDeploymentTopologyPath,
  useProjectModel
} from "./chunk-BUXKC4SM.js";
import {
  isHttpError,
  pRetry,
  resolveUrl,
  serializer
} from "./chunk-PLPLA7N3.js";
import {
  Box_default,
  Link,
  PointerSmallIcon,
  useAsyncCallback
} from "./chunk-OAVLQEAG.js";
import {
  require_react
} from "./chunk-5A5B2WR4.js";
import {
  getTestOverrides
} from "./chunk-WYHHEOWO.js";
import {
  pathExists,
  readJson,
  writeJson
} from "./chunk-P4ZPHTFX.js";
import {
  z
} from "./chunk-ZXYGJZOO.js";
import {
  CliError,
  CliErrorCode,
  require_lib
} from "./chunk-D5VYILRO.js";
import {
  __toESM,
  init_esm_shims
} from "./chunk-4EFJZ3GQ.js";

// ../arm-client/src/useARMClient.ts
init_esm_shims();
var import_react = __toESM(require_react(), 1);

// ../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",
      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",
      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",
      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",
      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",
      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/build/es/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",
      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/fieldValidations.ts
init_esm_shims();

// ../arm-client/src/schemas.ts
init_esm_shims();
var promoteAppVersionFromDraftToProductionSchema = z.object({
  fullVersion: z.string()
});
var commitComponentOverrideSchema = z.object({
  nextMajor: z.string(),
  nextMinor: z.string().optional()
});
var createAppReleaseSchema = z.object({
  tag: z.string()
});
var fieldValidationsSchema = z.array(
  z.object({
    description: z.string(),
    field: z.string()
  })
);
var releaseArm2Schema = z.object({
  releaseBaseUrl: z.string()
});

// ../arm-client/src/fieldValidations.ts
var parseFieldValidationError = (err) => {
  if (isHttpError(err)) {
    const fieldViolations = err.response?.data?.details?.validationError?.fieldViolations;
    if (fieldViolations) {
      const result = fieldValidationsSchema.safeParse(fieldViolations);
      if (result.success) {
        return result.data;
      }
      throw new CliError({
        cause: err,
        code: CliErrorCode.FailedToParseFieldValidationError(),
        info: {
          zodError: result.error
        }
      });
    }
  }
  return [];
};

// ../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 } = getTestOverrides();
    this.retryOptions = {
      maxTimeout: 3 * 1e3,
      minTimeout: minRetryTimeout,
      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) && e.response?.status === 403) {
        throw new CliError({
          cause: e,
          code: AppPermissionDenied({ appId: manifest.appId })
        });
      }
      const violations = parseFieldValidationError(e);
      if (violations.length > 0) {
        throw new CliError({
          cause: e,
          code: CliErrorCode.AppReleaseConfigViolations({
            violations
          })
        });
      }
      throw new CliError({
        cause: e,
        code: CliErrorCode.FailedToCreateAppRelease()
      });
    }
  };
  createLooseAppRelease = async (manifest, projectId) => {
    return this.createAppRelease(manifest, projectId);
  };
  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 })
          });
        }
      }
      throw new CliError({
        cause: e,
        code: CliErrorCode.FailedToUpdateAppRelease()
      });
    }
  };
  updateLooseAppRelease = async (manifest, tag) => {
    return this.updateAppRelease(manifest, tag);
  };
  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()
      });
    }
  };
  release = async (appId, componentOverrideId) => {
    try {
      const { data } = await pRetry(
        () => this.httpClient.request(
          release({
            appId,
            componentOverrideId
          })
        ),
        this.retryOptions
      );
      return releaseArm2Schema.parse(data).releaseBaseUrl;
    } catch (e) {
      throw new CliError({
        cause: e,
        code: CliErrorCode.FailedToReleaseHeadlessProject()
      });
    }
  };
};

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

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

// ../cli-astro-commands/src/components/PreviewCommand/hooks/useUpdateManifest.ts
init_esm_shims();
var import_react2 = __toESM(require_react(), 1);
var componentHandlers = {
  [ComponentType.WEBHOOK]: ({ component, serverUrl, tunnelUrl }) => {
    component.compData.webhook.callbackUrl = normalizeUrl(
      component.compData.webhook.callbackUrl,
      tunnelUrl ?? serverUrl
    );
  },
  [ComponentType.BACK_OFFICE_PAGE]: ({ component, serverUrl }) => {
    component.compData.backOfficePage.iframeUrl = normalizeUrl(
      component.compData.backOfficePage.iframeUrl,
      serverUrl
    );
  },
  [ComponentType.BACK_OFFICE_EXTENSION_WIDGET]: ({ component, serverUrl }) => {
    component.compData.backOfficeExtensionWidget.iframeUrl = normalizeUrl(
      component.compData.backOfficeExtensionWidget.iframeUrl,
      serverUrl
    );
  },
  [ComponentType.BACK_OFFICE_MODAL]: ({ component, serverUrl }) => {
    component.compData.backOfficeModal.iframeUrl = normalizeUrl(
      component.compData.backOfficeModal.iframeUrl,
      serverUrl
    );
  },
  [ComponentType.BACK_OFFICE_EXTENSION_MENU_ITEM]: ({
    component,
    serverUrl
  }) => {
    component.compData.backOfficeExtensionMenuItem.iframeUrl = normalizeUrl(
      component.compData.backOfficeExtensionMenuItem.iframeUrl,
      serverUrl
    );
  },
  [ComponentType.ECOM_SHIPPING_RATES]: ({
    component,
    serverUrl,
    tunnelUrl
  }) => {
    component.compData.ecomShippingRates.deploymentUri = normalizeUrl(
      component.compData.ecomShippingRates.deploymentUri,
      tunnelUrl ?? serverUrl
    );
  },
  [ComponentType.ECOM_ADDITIONAL_FEES]: ({
    component,
    serverUrl,
    tunnelUrl
  }) => {
    component.compData.ecomAdditionalFees.deploymentUri = normalizeUrl(
      component.compData.ecomAdditionalFees.deploymentUri,
      tunnelUrl ?? serverUrl
    );
  },
  [ComponentType.ECOM_DISCOUNTS_TRIGGER]: ({
    component,
    serverUrl,
    tunnelUrl
  }) => {
    component.compData.ecomDiscountsTrigger.deploymentUri = normalizeUrl(
      component.compData.ecomDiscountsTrigger.deploymentUri,
      tunnelUrl ?? serverUrl
    );
  },
  [ComponentType.ECOM_VALIDATIONS]: ({ component, serverUrl, tunnelUrl }) => {
    component.compData.ecomValidations.deploymentUri = normalizeUrl(
      component.compData.ecomValidations.deploymentUri,
      tunnelUrl ?? serverUrl
    );
  },
  [ComponentType.ECOM_PAYMENT_SETTINGS]: ({
    component,
    serverUrl,
    tunnelUrl
  }) => {
    component.compData.ecomPaymentSettings.deploymentUri = normalizeUrl(
      component.compData.ecomPaymentSettings.deploymentUri,
      tunnelUrl ?? serverUrl
    );
  },
  [ComponentType.GIFT_CARDS_PROVIDER]: ({
    component,
    serverUrl,
    tunnelUrl
  }) => {
    component.compData.giftCardsProvider.deploymentUri = normalizeUrl(
      component.compData.giftCardsProvider.deploymentUri,
      tunnelUrl ?? serverUrl
    );
  },
  [ComponentType.TOPOLOGY]: ({ component, serverUrl, tunnelUrl }) => {
    component.compData.topology.topology.backendApiUrl = tunnelUrl ?? serverUrl;
  }
};
function useUpdateManifest() {
  const updateManifest = (0, import_react2.useCallback)(
    (manifest, serverUrl, tunnelUrl) => {
      const clone = structuredClone(manifest);
      for (const component of clone.components) {
        const handler = getHandler(
          component,
          componentHandlers
        );
        handler?.({
          component,
          serverUrl,
          tunnelUrl
        });
      }
      return clone;
    },
    []
  );
  const updateManifestWithBackendWorker = (0, import_react2.useCallback)(
    (manifest, deploymentId, deploymentUrl, label, commitHash) => {
      const clone = structuredClone(manifest);
      clone.components.push({
        compId: BACKEND_WORKER_COMPONENT_ID,
        compType: ComponentType.BACKEND_WORKER,
        compData: {
          backendWorker: {
            deploymentId,
            deploymentUrl,
            label,
            commitHash
          }
        }
      });
      return clone;
    },
    []
  );
  return {
    updateManifest,
    updateManifestWithBackendWorker
  };
}
function getHandler(component, handlers) {
  return handlers[component.compType];
}
function normalizeUrl(inputUrl, baseUrl) {
  if (!inputUrl) {
    return baseUrl;
  }
  if (URL.canParse(inputUrl)) {
    return inputUrl;
  }
  const base = new URL(baseUrl);
  const normalizedUrl = new URL(inputUrl, base);
  if (base.search) {
    normalizedUrl.search = base.search;
  }
  return normalizedUrl.href;
}

// ../cli-astro-commands/src/components/PlatformLink/PlatformLink.tsx
init_esm_shims();
var import_react3 = __toESM(require_react(), 1);
var PlatformLink = ({ url, label }) => {
  return /* @__PURE__ */ import_react3.default.createElement(Box_default, { marginRight: 1 }, /* @__PURE__ */ import_react3.default.createElement(PointerSmallIcon, null), /* @__PURE__ */ import_react3.default.createElement(Box_default, { marginLeft: 1 }, /* @__PURE__ */ import_react3.default.createElement(Link, { url }, label)));
};

// ../cli-astro-commands/src/hooks/useUpdateDeploymentTopology.ts
init_esm_shims();
function useUpdateDeploymentTopology() {
  const {
    model: {
      projectFolder,
      config: { siteId }
    }
  } = useProjectModel();
  return useAsyncCallback(async (_, props) => {
    const { environment, serverUrl, armTag } = props;
    const topology = await readDeploymentTopology(projectFolder);
    topology[environment] = {
      id: armTag,
      site: {
        main: serverUrl
      },
      dashboard: {
        main: `https://manage.wix.com/dashboard/${siteId}?apps-override=${armTag}`
      }
    };
    const path = getDeploymentTopologyPath(projectFolder);
    await writeJson(path, topology, { spaces: 2 });
  });
}
async function readDeploymentTopology(projectFolder) {
  const path = getDeploymentTopologyPath(projectFolder);
  if (await pathExists(path)) {
    try {
      const deployment = await readJson(path);
      return deploymentTopologySchema.parse(deployment);
    } catch {
    }
  }
  return {};
}

export {
  useARMClient,
  useUpdateManifest,
  PlatformLink,
  useUpdateDeploymentTopology
};
//# sourceMappingURL=chunk-C4EZJBTU.js.map