@wix/astro 0.0.0-experimental-react-component → 0.0.1-experimental

package/build-runtime/chunk-FR26HCAT.js

@@ -0,0 +1,471 @@
+// ../../node_modules/@wix/sdk-runtime/build/constants.js
+var SDKRequestToRESTRequestRenameMap = {
+  _id: "id",
+  _createdDate: "createdDate",
+  _updatedDate: "updatedDate"
+};
+var RESTResponseToSDKResponseRenameMap = {
+  id: "_id",
+  createdDate: "_createdDate",
+  updatedDate: "_updatedDate"
+};
+var ITEMS_RESULT_PROPERTY_NAME = "items";
+var PAGING_METADATA_RESULT_PROPERTY_NAME = "pagingMetadata";
+var DEFAULT_LIMIT = 50;
+
+// ../../node_modules/@wix/sdk-runtime/build/utils.js
+function constantCase(input) {
+  return split(input).map((part) => part.toLocaleUpperCase()).join("_");
+}
+var SPLIT_LOWER_UPPER_RE = new RegExp("([\\p{Ll}\\d])(\\p{Lu})", "gu");
+var SPLIT_UPPER_UPPER_RE = new RegExp("(\\p{Lu})([\\p{Lu}][\\p{Ll}])", "gu");
+var SPLIT_REPLACE_VALUE = "$1\0$2";
+var DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+function split(value) {
+  let result = value.trim();
+  result = result.replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE).replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+  result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+  let start = 0;
+  let end = result.length;
+  while (result.charAt(start) === "\0") {
+    start++;
+  }
+  if (start === end) {
+    return [];
+  }
+  while (result.charAt(end - 1) === "\0") {
+    end--;
+  }
+  return result.slice(start, end).split(/\0/g);
+}
+
+// ../../node_modules/@wix/sdk-runtime/build/transform-error.js
+var isValidationError = (httpClientError) => "validationError" in (httpClientError.response?.data?.details ?? {});
+var isApplicationError = (httpClientError) => "applicationError" in (httpClientError.response?.data?.details ?? {});
+var isClientError = (httpClientError) => (httpClientError.response?.status ?? -1) >= 400 && (httpClientError.response?.status ?? -1) < 500;
+function transformError(httpClientError, pathsToArguments = {
+  explicitPathsToArguments: {},
+  spreadPathsToArguments: {},
+  singleArgumentUnchanged: false
+}, argumentNames = []) {
+  if (typeof httpClientError !== "object" || httpClientError === null) {
+    throw httpClientError;
+  }
+  if (isValidationError(httpClientError)) {
+    return buildValidationError(httpClientError, pathsToArguments, argumentNames);
+  }
+  if (isApplicationError(httpClientError)) {
+    return buildApplicationError(httpClientError);
+  }
+  if (isClientError(httpClientError)) {
+    const status = httpClientError.response?.status;
+    const statusText = httpClientError.response?.statusText ?? "UNKNOWN";
+    const message = httpClientError.response?.data?.message ?? statusText;
+    const details = {
+      applicationError: {
+        description: statusText,
+        code: constantCase(statusText),
+        data: {}
+      },
+      requestId: httpClientError.requestId
+    };
+    return buildError({
+      message: JSON.stringify({
+        message,
+        details
+      }, null, 2),
+      extraProperties: { details, status }
+    });
+  }
+  return buildSystemError(httpClientError);
+}
+var buildValidationError = (httpClientError, pathsToArguments, argumentNames) => {
+  const validationErrorResponse = httpClientError.response?.data;
+  const requestId = httpClientError.requestId;
+  const { fieldViolations } = validationErrorResponse.details.validationError;
+  const transformedFieldViolations = violationsWithRenamedFields(pathsToArguments, fieldViolations, argumentNames)?.sort((a, b) => a.field < b.field ? -1 : 1);
+  const message = `INVALID_ARGUMENT: ${transformedFieldViolations?.map(({ field, description }) => `"${field}" ${description}`)?.join(", ")}`;
+  const details = {
+    validationError: { fieldViolations: transformedFieldViolations },
+    requestId
+  };
+  return buildError({
+    message: JSON.stringify({ message, details }, null, 2),
+    extraProperties: {
+      details,
+      status: httpClientError.response?.status,
+      requestId
+    }
+  });
+};
+var buildError = ({ message, extraProperties }) => {
+  const error = new Error(message);
+  return Object.assign(error, extraProperties);
+};
+var buildApplicationError = (httpClientError) => {
+  const status = httpClientError.response?.status;
+  const statusText = httpClientError.response?.statusText ?? "UNKNOWN";
+  const message = httpClientError.response?.data?.message ?? statusText;
+  const description = httpClientError.response?.data?.details?.applicationError?.description ?? statusText;
+  const code = httpClientError.response?.data?.details?.applicationError?.code ?? constantCase(statusText);
+  const data = httpClientError.response?.data?.details?.applicationError?.data ?? {};
+  const combinedMessage = message === description ? message : `${message}: ${description}`;
+  const details = {
+    applicationError: {
+      description,
+      code,
+      data
+    },
+    requestId: httpClientError.requestId
+  };
+  return buildError({
+    message: JSON.stringify({ message: combinedMessage, details }, null, 2),
+    extraProperties: {
+      details,
+      status,
+      requestId: httpClientError.requestId
+    }
+  });
+};
+var buildSystemError = (httpClientError) => {
+  const message = httpClientError.requestId ? `System error occurred, request-id: ${httpClientError.requestId}` : `System error occurred: ${JSON.stringify(httpClientError)}`;
+  return buildError({
+    message,
+    extraProperties: {
+      requestId: httpClientError.requestId,
+      status: httpClientError.response?.status,
+      code: constantCase(httpClientError.response?.statusText ?? "UNKNOWN"),
+      ...!httpClientError.response && {
+        runtimeError: httpClientError
+      }
+    }
+  });
+};
+var violationsWithRenamedFields = ({ spreadPathsToArguments, explicitPathsToArguments, singleArgumentUnchanged }, fieldViolations, argumentNames) => {
+  const allPathsToArguments = {
+    ...spreadPathsToArguments,
+    ...explicitPathsToArguments
+  };
+  const allPathsToArgumentsKeys = Object.keys(allPathsToArguments);
+  return fieldViolations?.filter((fieldViolation) => {
+    const containedInAMoreSpecificViolationField = fieldViolations.some((anotherViolation) => anotherViolation.field.length > fieldViolation.field.length && anotherViolation.field.startsWith(fieldViolation.field) && allPathsToArgumentsKeys.includes(anotherViolation.field));
+    return !containedInAMoreSpecificViolationField;
+  }).map((fieldViolation) => {
+    const exactMatchArgumentExpression = explicitPathsToArguments[fieldViolation.field];
+    if (exactMatchArgumentExpression) {
+      return {
+        ...fieldViolation,
+        field: withRenamedArgument(exactMatchArgumentExpression, argumentNames)
+      };
+    }
+    const longestPartialPathMatch = allPathsToArgumentsKeys?.sort((a, b) => b.length - a.length)?.find((path) => fieldViolation.field.startsWith(path));
+    if (longestPartialPathMatch) {
+      const partialMatchArgumentExpression = allPathsToArguments[longestPartialPathMatch];
+      if (partialMatchArgumentExpression) {
+        return {
+          ...fieldViolation,
+          field: fieldViolation.field.replace(longestPartialPathMatch, withRenamedArgument(partialMatchArgumentExpression, argumentNames))
+        };
+      }
+    }
+    if (singleArgumentUnchanged) {
+      return {
+        ...fieldViolation,
+        field: `${argumentNames[0]}.${fieldViolation.field}`
+      };
+    }
+    return fieldViolation;
+  });
+};
+var withRenamedArgument = (fieldValue, argumentNames) => {
+  const argIndex = getArgumentIndex(fieldValue);
+  if (argIndex !== null && typeof argIndex !== "undefined") {
+    return fieldValue.replace(`$[${argIndex}]`, argumentNames[argIndex]);
+  }
+  return fieldValue;
+};
+var getArgumentIndex = (s) => {
+  const match = s.match(/\$\[(?<argIndex>\d+)\]/);
+  return match && match.groups && Number(match.groups.argIndex);
+};
+
+// ../../node_modules/@wix/sdk-runtime/build/rename-all-nested-keys.js
+function renameAllNestedKeys(payload, renameMap, ignorePaths) {
+  const isIgnored = (path) => ignorePaths.includes(path);
+  const traverse = (obj, path) => {
+    if (Array.isArray(obj)) {
+      obj.forEach((item) => {
+        traverse(item, path);
+      });
+    } else if (typeof obj === "object" && obj !== null) {
+      const objAsRecord = obj;
+      Object.keys(objAsRecord).forEach((key) => {
+        const newPath = path === "" ? key : `${path}.${key}`;
+        if (isIgnored(newPath)) {
+          return;
+        }
+        if (key in renameMap && !(renameMap[key] in objAsRecord)) {
+          objAsRecord[renameMap[key]] = objAsRecord[key];
+          delete objAsRecord[key];
+        }
+        traverse(objAsRecord[key], newPath);
+      });
+    }
+  };
+  traverse(payload, "");
+  return payload;
+}
+function renameKeysFromSDKRequestToRESTRequest(payload, ignorePaths = []) {
+  return renameAllNestedKeys(payload, SDKRequestToRESTRequestRenameMap, ignorePaths);
+}
+function renameKeysFromRESTResponseToSDKResponse(payload, ignorePaths = []) {
+  return renameAllNestedKeys(payload, RESTResponseToSDKResponseRenameMap, ignorePaths);
+}
+
+// ../../node_modules/@wix/sdk-types/build/index.mjs
+function EventDefinition(type, isDomainEvent = false, transformations = (x) => x) {
+  return () => ({
+    __type: "event-definition",
+    type,
+    isDomainEvent,
+    transformations
+  });
+}
+
+// ../../node_modules/@wix/sdk-context/build/index.mjs
+var wixContext = {};
+
+// ../../node_modules/@wix/sdk-runtime/build/context.js
+function resolveContext() {
+  const oldContext = typeof $wixContext !== "undefined" && $wixContext.initWixModules ? $wixContext.initWixModules : typeof globalThis.__wix_context__ !== "undefined" && globalThis.__wix_context__.initWixModules ? globalThis.__wix_context__.initWixModules : void 0;
+  if (oldContext) {
+    return {
+      // @ts-expect-error
+      initWixModules(modules, elevated) {
+        return runWithoutContext(() => oldContext(modules, elevated));
+      },
+      fetchWithAuth() {
+        throw new Error("fetchWithAuth is not available in this context");
+      },
+      graphql() {
+        throw new Error("graphql is not available in this context");
+      }
+    };
+  }
+  const contextualClient = typeof $wixContext !== "undefined" ? $wixContext.client : typeof wixContext.client !== "undefined" ? wixContext.client : typeof globalThis.__wix_context__ !== "undefined" ? globalThis.__wix_context__.client : void 0;
+  const elevatedClient = typeof $wixContext !== "undefined" ? $wixContext.elevatedClient : typeof wixContext.elevatedClient !== "undefined" ? wixContext.elevatedClient : typeof globalThis.__wix_context__ !== "undefined" ? globalThis.__wix_context__.elevatedClient : void 0;
+  if (!contextualClient && !elevatedClient) {
+    return;
+  }
+  return {
+    initWixModules(wixModules, elevated) {
+      if (elevated) {
+        if (!elevatedClient) {
+          throw new Error("An elevated client is required to use elevated modules. Make sure to initialize the Wix context with an elevated client before using elevated SDK modules");
+        }
+        return runWithoutContext(() => elevatedClient.use(wixModules));
+      }
+      if (!contextualClient) {
+        throw new Error("Wix context is not available. Make sure to initialize the Wix context before using SDK modules");
+      }
+      return runWithoutContext(() => contextualClient.use(wixModules));
+    },
+    fetchWithAuth: (urlOrRequest, requestInit) => {
+      if (!contextualClient) {
+        throw new Error("Wix context is not available. Make sure to initialize the Wix context before using SDK modules");
+      }
+      return contextualClient.fetchWithAuth(urlOrRequest, requestInit);
+    },
+    getAuth() {
+      if (!contextualClient) {
+        throw new Error("Wix context is not available. Make sure to initialize the Wix context before using SDK modules");
+      }
+      return contextualClient.auth;
+    },
+    async graphql(query, variables, opts) {
+      if (!contextualClient) {
+        throw new Error("Wix context is not available. Make sure to initialize the Wix context before using SDK modules");
+      }
+      return contextualClient.graphql(query, variables, opts);
+    }
+  };
+}
+function runWithoutContext(fn) {
+  const globalContext = globalThis.__wix_context__;
+  const moduleContext = {
+    client: wixContext.client,
+    elevatedClient: wixContext.elevatedClient
+  };
+  let closureContext;
+  globalThis.__wix_context__ = void 0;
+  wixContext.client = void 0;
+  wixContext.elevatedClient = void 0;
+  if (typeof $wixContext !== "undefined") {
+    closureContext = {
+      client: $wixContext?.client,
+      elevatedClient: $wixContext?.elevatedClient
+    };
+    delete $wixContext.client;
+    delete $wixContext.elevatedClient;
+  }
+  try {
+    return fn();
+  } finally {
+    globalThis.__wix_context__ = globalContext;
+    wixContext.client = moduleContext.client;
+    wixContext.elevatedClient = moduleContext.elevatedClient;
+    if (typeof $wixContext !== "undefined") {
+      $wixContext.client = closureContext.client;
+      $wixContext.elevatedClient = closureContext.elevatedClient;
+    }
+  }
+}
+
+// ../../node_modules/@wix/sdk-runtime/build/context-v2.js
+function contextualizeRESTModuleV2(restModule, elevated) {
+  return (...args) => {
+    const context = resolveContext();
+    if (!context) {
+      return restModule.apply(void 0, args);
+    }
+    return context.initWixModules(restModule, elevated).apply(void 0, args);
+  };
+}
+function contextualizeEventDefinitionModuleV2(eventDefinition) {
+  const contextualMethod = (...args) => {
+    const context = resolveContext();
+    if (!context) {
+      return () => {
+      };
+    }
+    return context.initWixModules(eventDefinition).apply(void 0, args);
+  };
+  contextualMethod.__type = eventDefinition.__type;
+  contextualMethod.type = eventDefinition.type;
+  contextualMethod.isDomainEvent = eventDefinition.isDomainEvent;
+  contextualMethod.transformations = eventDefinition.transformations;
+  return contextualMethod;
+}
+
+// ../../node_modules/@wix/sdk-runtime/build/rest-modules.js
+function createRESTModule(descriptor, elevated = false) {
+  return contextualizeRESTModuleV2(descriptor, elevated);
+}
+function toURLSearchParams(params, isComplexRequest) {
+  const flatten = flattenParams(params);
+  const isPayloadNonSerializableAsUrlSearchParams = Object.entries(flatten).some(([key, value]) => key.includes(".") || Array.isArray(value) && value.some((v) => typeof v === "object"));
+  const shouldSerializeToRParam = isComplexRequest && isPayloadNonSerializableAsUrlSearchParams;
+  if (shouldSerializeToRParam) {
+    return new URLSearchParams({ ".r": base64Encode(JSON.stringify(params)) });
+  } else {
+    return Object.entries(flatten).reduce((urlSearchParams, [key, value]) => {
+      const keyParams = Array.isArray(value) ? value : [value];
+      keyParams.forEach((param) => {
+        if (param === void 0 || param === null || Array.isArray(value) && typeof param === "object") {
+          return;
+        }
+        urlSearchParams.append(key, param);
+      });
+      return urlSearchParams;
+    }, new URLSearchParams());
+  }
+}
+function resolveUrl(opts) {
+  const domain = resolveDomain(opts.host);
+  const mappings = resolveMappingsByDomain(domain, opts.domainToMappings);
+  const path = injectDataIntoProtoPath(opts.protoPath, opts.data || {});
+  return resolvePathFromMappings(path, mappings);
+}
+function flattenParams(data, path = "") {
+  const params = {};
+  Object.entries(data).forEach(([key, value]) => {
+    const isObject = value !== null && typeof value === "object" && !Array.isArray(value);
+    const fieldPath = resolvePath(path, key);
+    if (isObject) {
+      const serializedObject = flattenParams(value, fieldPath);
+      Object.assign(params, serializedObject);
+    } else {
+      params[fieldPath] = value;
+    }
+  });
+  return params;
+}
+function resolvePath(path, key) {
+  return `${path}${path ? "." : ""}${key}`;
+}
+var base64Encode = (value) => {
+  const base64 = typeof btoa !== "undefined" ? btoa(value) : Buffer.from(value, "utf-8").toString("base64");
+  return base64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+};
+var DOMAINS = ["wix.com", "editorx.com"];
+var USER_DOMAIN = "_";
+var REGEX_CAPTURE_DOMAINS = new RegExp(`\\.(${DOMAINS.join("|")})$`);
+var WIX_API_DOMAINS = ["42.wixprod.net", "uw2-edt-1.wixprod.net"];
+var DEV_WIX_CODE_DOMAIN = "dev.wix-code.com";
+var REGEX_CAPTURE_PROTO_FIELD = /{(.*)}/;
+var REGEX_CAPTURE_API_DOMAINS = new RegExp(`\\.(${WIX_API_DOMAINS.join("|")})$`);
+var REGEX_CAPTURE_DEV_WIX_CODE_DOMAIN = new RegExp(`.*\\.${DEV_WIX_CODE_DOMAIN}$`);
+function resolveDomain(host) {
+  const resolvedHost = fixHostExceptions(host);
+  return resolvedHost.replace(REGEX_CAPTURE_DOMAINS, "._base_domain_").replace(REGEX_CAPTURE_API_DOMAINS, "._api_base_domain_").replace(REGEX_CAPTURE_DEV_WIX_CODE_DOMAIN, "*.dev.wix-code.com");
+}
+function fixHostExceptions(host) {
+  return host.replace("create.editorx.com", "editor.editorx.com");
+}
+function resolveMappingsByDomain(domain, domainToMappings) {
+  const mappings = domainToMappings[domain] || domainToMappings[USER_DOMAIN];
+  if (!mappings) {
+    if (isBaseDomain(domain)) {
+      return domainToMappings[wwwBaseDomain];
+    }
+  }
+  return mappings;
+}
+function isBaseDomain(domain) {
+  return !!domain.match(/\._base_domain_$/);
+}
+var wwwBaseDomain = "www._base_domain_";
+function injectDataIntoProtoPath(protoPath, data) {
+  return protoPath.split("/").map((path) => maybeProtoPathToData(path, data)).join("/");
+}
+function maybeProtoPathToData(protoPath, data) {
+  const protoRegExpMatch = protoPath.match(REGEX_CAPTURE_PROTO_FIELD) || [];
+  const field = protoRegExpMatch[1];
+  if (field) {
+    const suffix = protoPath.replace(protoRegExpMatch[0], "");
+    return findByPath(data, field, protoPath, suffix);
+  }
+  return protoPath;
+}
+function findByPath(obj, path, defaultValue, suffix) {
+  let result = obj;
+  for (const field of path.split(".")) {
+    if (!result) {
+      return defaultValue;
+    }
+    result = result[field];
+  }
+  return `${result}${suffix}`;
+}
+function resolvePathFromMappings(protoPath, mappings) {
+  const mapping = mappings?.find((m) => protoPath.startsWith(m.destPath));
+  if (!mapping) {
+    return protoPath;
+  }
+  return mapping.srcPath + protoPath.slice(mapping.destPath.length);
+}
+
+export {
+  SDKRequestToRESTRequestRenameMap,
+  ITEMS_RESULT_PROPERTY_NAME,
+  PAGING_METADATA_RESULT_PROPERTY_NAME,
+  DEFAULT_LIMIT,
+  transformError,
+  renameKeysFromSDKRequestToRESTRequest,
+  renameKeysFromRESTResponseToSDKResponse,
+  EventDefinition,
+  contextualizeEventDefinitionModuleV2,
+  createRESTModule,
+  toURLSearchParams,
+  resolveUrl
+};