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

package/build-runtime/chunk-24J7STEA.js

@@ -0,0 +1,8 @@
+// src/constants.ts
+var oAuthStateCookieName = "oAuthState";
+var returnToQueryParamName = "returnTo";
+
+export {
+  oAuthStateCookieName,
+  returnToQueryParamName
+};

package/build-runtime/chunk-B6RICTPP.js

@@ -0,0 +1,94 @@
+import {
+  authAsyncLocalStorage
+} from "./chunk-NVTQFGTR.js";
+
+// ../../node_modules/@wix/headless-node/dist/esm/headers/common-config-header.js
+var COMMON_CONFIG_HEADER_NAME = "commonConfig";
+var BSI_COOKIE_NAME = "bSession";
+var getCommonConfigHeader = (req) => {
+  let value = req.headers.get(COMMON_CONFIG_HEADER_NAME);
+  if (!value) {
+    const cookies = req.headers.get("cookie");
+    const bsiCookie = cookies == null ? void 0 : cookies.split(";").find((keyValue) => keyValue.trim().startsWith(`${BSI_COOKIE_NAME}=`));
+    value = bsiCookie ? encodeURIComponent(JSON.stringify({
+      BSI: bsiCookie.split("=")[1]
+    })) : "";
+  }
+  return {
+    [COMMON_CONFIG_HEADER_NAME]: value
+  };
+};
+
+// ../../node_modules/@wix/headless-node/dist/esm/headers/index.js
+var getPassThroughHeaders = (req) => {
+  if (!req) {
+    return {};
+  }
+  const headers = [getCommonConfigHeader(req)];
+  return headers.reduce((res, header) => {
+    const entries = Object.entries(header).filter((_ref) => {
+      let [_, value] = _ref;
+      return !!value;
+    });
+    res = {
+      ...res,
+      ...Object.fromEntries(entries)
+    };
+    return res;
+  }, {});
+};
+
+// ../../node_modules/@wix/headless-node/dist/esm/host-module.js
+var createHostModule = () => {
+  return {
+    __type: "host",
+    create: () => {
+      return {};
+    },
+    host: function(_temp) {
+      let {
+        req
+      } = _temp === void 0 ? {} : _temp;
+      const passThroughHeaders = getPassThroughHeaders(req);
+      return {
+        essentials: {
+          passThroughHeaders
+        }
+      };
+    }
+  };
+};
+
+// ../../node_modules/@wix/headless-node/dist/esm/index.js
+var headlessNode = createHostModule();
+
+// src/context/hostProxy.ts
+var createHostWithCurrentRequest = () => {
+  const store = authAsyncLocalStorage.getStore();
+  return headlessNode.host({ req: store?.request });
+};
+var createHostProxy = () => {
+  return new Proxy(
+    {},
+    {
+      get(target, prop) {
+        const host = createHostWithCurrentRequest();
+        const value = host[prop];
+        if (typeof value !== "function") {
+          return value;
+        }
+        return function(...args) {
+          const anotherHost = createHostWithCurrentRequest();
+          return anotherHost[prop].apply(
+            anotherHost,
+            args
+          );
+        };
+      }
+    }
+  );
+};
+
+export {
+  createHostProxy
+};

package/build-runtime/chunk-C3QOE2TZ.js

@@ -0,0 +1,7 @@
+// src/utils/authAsyncLocalStorage.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var authAsyncLocalStorage = new AsyncLocalStorage();
+
+export {
+  authAsyncLocalStorage
+};

package/build-runtime/chunk-EK7YZVWJ.js

@@ -0,0 +1,353 @@
+import {
+  contextualizeRESTModuleV2
+} from "./chunk-PSHIUVP2.js";
+
+// ../../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 wrapError(httpClientError, {
+      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 wrapError(httpClientError, {
+    message: JSON.stringify({ message, details }, null, 2),
+    extraProperties: {
+      details,
+      status: httpClientError.response?.status,
+      requestId
+    }
+  });
+};
+var wrapError = (baseError, { message, extraProperties }) => {
+  return Object.assign(baseError, {
+    ...extraProperties,
+    message
+  });
+};
+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 wrapError(httpClientError, {
+    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 wrapError(httpClientError, {
+    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-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,
+  createRESTModule,
+  toURLSearchParams,
+  resolveUrl
+};