cloudcommerce 0.26.2 → 0.26.3

package/packages/storefront/dist/server/chunks/pages/account.astro.f11f26f3.mjs

@@ -0,0 +1,15 @@
+import { c as createAstro, b as createComponent, r as renderTemplate } from '../astro.440a2e08.mjs';
+import 'clsx';
+import 'html-escaper';
+
+const $$Astro = createAstro("https://ecom2-demo.web.app");
+const $$Account = createComponent(async ($$result, $$props, $$slots) => {
+  const Astro2 = $$result.createAstro($$Astro, $$props, $$slots);
+  Astro2.self = $$Account;
+  return renderTemplate``;
+}, "/home/leo/code/ecomplus/cloud-commerce/packages/storefront/src/pages/app/account.astro", void 0);
+
+const $$file = "/home/leo/code/ecomplus/cloud-commerce/packages/storefront/src/pages/app/account.astro";
+const $$url = "/app/account";
+
+export { $$Account as default, $$file as file, $$url as url };

package/packages/storefront/dist/server/chunks/pages/image-endpoint.js.a9374d3e.mjs

@@ -0,0 +1,238 @@
+import { isRemotePath } from '@astrojs/internal-helpers/path';
+import mime from 'mime/lite.js';
+import { i as imageConfig } from './_...slug_.astro.08ba5973.mjs';
+import '../astro.440a2e08.mjs';
+import 'clsx';
+import 'html-escaper';
+import '@cloudcommerce/api';
+import 'node:events';
+import 'node:fs';
+import 'node:path';
+import '@cloudcommerce/config';
+import '@ecomplus/utils';
+import 'ultrahtml';
+/* empty css                               */import 'image-size';
+import 'mime';
+import 'vue';
+import '@vueuse/core';
+import 'vue/server-renderer';
+import '@headlessui/vue';
+
+const InvalidImageService = {
+  name: "InvalidImageService",
+  title: "Error while loading image service.",
+  message: "There was an error loading the configured image service. Please see the stack trace for more information."
+};
+
+function normalizeLF(code) {
+  return code.replace(/\r\n|\r(?!\n)|\n/g, "\n");
+}
+
+function codeFrame(src, loc) {
+  if (!loc || loc.line === void 0 || loc.column === void 0) {
+    return "";
+  }
+  const lines = normalizeLF(src).split("\n").map((ln) => ln.replace(/\t/g, "  "));
+  const visibleLines = [];
+  for (let n = -2; n <= 2; n++) {
+    if (lines[loc.line + n])
+      visibleLines.push(loc.line + n);
+  }
+  let gutterWidth = 0;
+  for (const lineNo of visibleLines) {
+    let w = `> ${lineNo}`;
+    if (w.length > gutterWidth)
+      gutterWidth = w.length;
+  }
+  let output = "";
+  for (const lineNo of visibleLines) {
+    const isFocusedLine = lineNo === loc.line - 1;
+    output += isFocusedLine ? "> " : "  ";
+    output += `${lineNo + 1} | ${lines[lineNo]}
+`;
+    if (isFocusedLine)
+      output += `${Array.from({ length: gutterWidth }).join(" ")}  | ${Array.from({
+        length: loc.column
+      }).join(" ")}^
+`;
+  }
+  return output;
+}
+
+class AstroError extends Error {
+  loc;
+  title;
+  hint;
+  frame;
+  type = "AstroError";
+  constructor(props, ...params) {
+    super(...params);
+    const { name, title, message, stack, location, hint, frame } = props;
+    this.title = title;
+    this.name = name;
+    if (message)
+      this.message = message;
+    this.stack = stack ? stack : this.stack;
+    this.loc = location;
+    this.hint = hint;
+    this.frame = frame;
+  }
+  setLocation(location) {
+    this.loc = location;
+  }
+  setName(name) {
+    this.name = name;
+  }
+  setMessage(message) {
+    this.message = message;
+  }
+  setHint(hint) {
+    this.hint = hint;
+  }
+  setFrame(source, location) {
+    this.frame = codeFrame(source, location);
+  }
+  static is(err) {
+    return err.type === "AstroError";
+  }
+}
+
+function matchPattern(url, remotePattern) {
+  return matchProtocol(url, remotePattern.protocol) && matchHostname(url, remotePattern.hostname, true) && matchPort(url, remotePattern.port) && matchPathname(url, remotePattern.pathname, true);
+}
+function matchPort(url, port) {
+  return !port || port === url.port;
+}
+function matchProtocol(url, protocol) {
+  return !protocol || protocol === url.protocol.slice(0, -1);
+}
+function matchHostname(url, hostname, allowWildcard) {
+  if (!hostname) {
+    return true;
+  } else if (!allowWildcard || !hostname.startsWith("*")) {
+    return hostname === url.hostname;
+  } else if (hostname.startsWith("**.")) {
+    const slicedHostname = hostname.slice(2);
+    return slicedHostname !== url.hostname && url.hostname.endsWith(slicedHostname);
+  } else if (hostname.startsWith("*.")) {
+    const slicedHostname = hostname.slice(1);
+    const additionalSubdomains = url.hostname.replace(slicedHostname, "").split(".").filter(Boolean);
+    return additionalSubdomains.length === 1;
+  }
+  return false;
+}
+function matchPathname(url, pathname, allowWildcard) {
+  if (!pathname) {
+    return true;
+  } else if (!allowWildcard || !pathname.endsWith("*")) {
+    return pathname === url.pathname;
+  } else if (pathname.endsWith("/**")) {
+    const slicedPathname = pathname.slice(0, -2);
+    return slicedPathname !== url.pathname && url.pathname.startsWith(slicedPathname);
+  } else if (pathname.endsWith("/*")) {
+    const slicedPathname = pathname.slice(0, -1);
+    const additionalPathChunks = url.pathname.replace(slicedPathname, "").split("/").filter(Boolean);
+    return additionalPathChunks.length === 1;
+  }
+  return false;
+}
+
+function isRemoteAllowed(src, {
+  domains = [],
+  remotePatterns = []
+}) {
+  if (!isRemotePath(src))
+    return true;
+  const url = new URL(src);
+  return domains.some((domain) => matchHostname(url, domain)) || remotePatterns.some((remotePattern) => matchPattern(url, remotePattern));
+}
+async function getConfiguredImageService() {
+  if (!globalThis?.astroAsset?.imageService) {
+    const { default: service } = await import(
+      // @ts-expect-error
+      '../sharp.52841bb4.mjs'
+    ).catch((e) => {
+      const error = new AstroError(InvalidImageService);
+      error.cause = e;
+      throw error;
+    });
+    if (!globalThis.astroAsset)
+      globalThis.astroAsset = {};
+    globalThis.astroAsset.imageService = service;
+    return service;
+  }
+  return globalThis.astroAsset.imageService;
+}
+
+const fnv1a52 = (str) => {
+  const len = str.length;
+  let i = 0, t0 = 0, v0 = 8997, t1 = 0, v1 = 33826, t2 = 0, v2 = 40164, t3 = 0, v3 = 52210;
+  while (i < len) {
+    v0 ^= str.charCodeAt(i++);
+    t0 = v0 * 435;
+    t1 = v1 * 435;
+    t2 = v2 * 435;
+    t3 = v3 * 435;
+    t2 += v0 << 8;
+    t3 += v1 << 8;
+    t1 += t0 >>> 16;
+    v0 = t0 & 65535;
+    t2 += t1 >>> 16;
+    v1 = t1 & 65535;
+    v3 = t3 + (t2 >>> 16) & 65535;
+    v2 = t2 & 65535;
+  }
+  return (v3 & 15) * 281474976710656 + v2 * 4294967296 + v1 * 65536 + (v0 ^ v3 >> 4);
+};
+const etag = (payload, weak = false) => {
+  const prefix = weak ? 'W/"' : '"';
+  return prefix + fnv1a52(payload).toString(36) + payload.length.toString(36) + '"';
+};
+
+async function loadRemoteImage(src) {
+  try {
+    const res = await fetch(src);
+    if (!res.ok) {
+      return void 0;
+    }
+    return Buffer.from(await res.arrayBuffer());
+  } catch (err) {
+    return void 0;
+  }
+}
+const GET = async ({ request }) => {
+  try {
+    const imageService = await getConfiguredImageService();
+    if (!("transform" in imageService)) {
+      throw new Error("Configured image service is not a local service");
+    }
+    const url = new URL(request.url);
+    const transform = await imageService.parseURL(url, imageConfig);
+    if (!transform?.src) {
+      throw new Error("Incorrect transform returned by `parseURL`");
+    }
+    let inputBuffer = void 0;
+    const sourceUrl = isRemotePath(transform.src) ? new URL(transform.src) : new URL(transform.src, url.origin);
+    if (isRemotePath(transform.src) && isRemoteAllowed(transform.src, imageConfig) === false) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    inputBuffer = await loadRemoteImage(sourceUrl);
+    if (!inputBuffer) {
+      return new Response("Not Found", { status: 404 });
+    }
+    const { data, format } = await imageService.transform(inputBuffer, transform, imageConfig);
+    return new Response(data, {
+      status: 200,
+      headers: {
+        "Content-Type": mime.getType(format) ?? `image/${format}`,
+        "Cache-Control": "public, max-age=31536000",
+        ETag: etag(data.toString()),
+        Date: (/* @__PURE__ */ new Date()).toUTCString()
+      }
+    });
+  } catch (err) {
+    return new Response(`Server Error: ${err}`, { status: 500 });
+  }
+};
+
+export { GET };