cloudcommerce 0.26.2 → 0.26.3

package/packages/storefront/dist/server/manifest.12e7a10c.mjs

@@ -0,0 +1,561 @@
+import { serialize, parse } from 'cookie';
+import { bold } from 'kleur/colors';
+import 'string-width';
+import '@astrojs/internal-helpers/path';
+import { A as AstroError, w as ResponseSentError, z as MiddlewareNoDataOrNextCalled, B as MiddlewareNotAResponse, D as ASTRO_VERSION, C as ClientAddressNotAvailable, S as StaticClientAddressNotAvailable, H as renderEndpoint, q as LocalsNotAnObject } from './chunks/astro.440a2e08.mjs';
+import 'clsx';
+import mime from 'mime';
+import { compile } from 'path-to-regexp';
+import 'html-escaper';
+
+const DELETED_EXPIRATION = /* @__PURE__ */ new Date(0);
+const DELETED_VALUE = "deleted";
+const responseSentSymbol = Symbol.for("astro.responseSent");
+class AstroCookie {
+  constructor(value) {
+    this.value = value;
+  }
+  json() {
+    if (this.value === void 0) {
+      throw new Error(`Cannot convert undefined to an object.`);
+    }
+    return JSON.parse(this.value);
+  }
+  number() {
+    return Number(this.value);
+  }
+  boolean() {
+    if (this.value === "false")
+      return false;
+    if (this.value === "0")
+      return false;
+    return Boolean(this.value);
+  }
+}
+class AstroCookies {
+  #request;
+  #requestValues;
+  #outgoing;
+  constructor(request) {
+    this.#request = request;
+    this.#requestValues = null;
+    this.#outgoing = null;
+  }
+  /**
+   * Astro.cookies.delete(key) is used to delete a cookie. Using this method will result
+   * in a Set-Cookie header added to the response.
+   * @param key The cookie to delete
+   * @param options Options related to this deletion, such as the path of the cookie.
+   */
+  delete(key, options) {
+    const serializeOptions = {
+      expires: DELETED_EXPIRATION
+    };
+    if (options?.domain) {
+      serializeOptions.domain = options.domain;
+    }
+    if (options?.path) {
+      serializeOptions.path = options.path;
+    }
+    this.#ensureOutgoingMap().set(key, [
+      DELETED_VALUE,
+      serialize(key, DELETED_VALUE, serializeOptions),
+      false
+    ]);
+  }
+  /**
+   * Astro.cookies.get(key) is used to get a cookie value. The cookie value is read from the
+   * request. If you have set a cookie via Astro.cookies.set(key, value), the value will be taken
+   * from that set call, overriding any values already part of the request.
+   * @param key The cookie to get.
+   * @returns An object containing the cookie value as well as convenience methods for converting its value.
+   */
+  get(key) {
+    if (this.#outgoing?.has(key)) {
+      let [serializedValue, , isSetValue] = this.#outgoing.get(key);
+      if (isSetValue) {
+        return new AstroCookie(serializedValue);
+      } else {
+        return void 0;
+      }
+    }
+    const values = this.#ensureParsed();
+    if (key in values) {
+      const value = values[key];
+      return new AstroCookie(value);
+    }
+  }
+  /**
+   * Astro.cookies.has(key) returns a boolean indicating whether this cookie is either
+   * part of the initial request or set via Astro.cookies.set(key)
+   * @param key The cookie to check for.
+   * @returns
+   */
+  has(key) {
+    if (this.#outgoing?.has(key)) {
+      let [, , isSetValue] = this.#outgoing.get(key);
+      return isSetValue;
+    }
+    const values = this.#ensureParsed();
+    return !!values[key];
+  }
+  /**
+   * Astro.cookies.set(key, value) is used to set a cookie's value. If provided
+   * an object it will be stringified via JSON.stringify(value). Additionally you
+   * can provide options customizing how this cookie will be set, such as setting httpOnly
+   * in order to prevent the cookie from being read in client-side JavaScript.
+   * @param key The name of the cookie to set.
+   * @param value A value, either a string or other primitive or an object.
+   * @param options Options for the cookie, such as the path and security settings.
+   */
+  set(key, value, options) {
+    let serializedValue;
+    if (typeof value === "string") {
+      serializedValue = value;
+    } else {
+      let toStringValue = value.toString();
+      if (toStringValue === Object.prototype.toString.call(value)) {
+        serializedValue = JSON.stringify(value);
+      } else {
+        serializedValue = toStringValue;
+      }
+    }
+    const serializeOptions = {};
+    if (options) {
+      Object.assign(serializeOptions, options);
+    }
+    this.#ensureOutgoingMap().set(key, [
+      serializedValue,
+      serialize(key, serializedValue, serializeOptions),
+      true
+    ]);
+    if (this.#request[responseSentSymbol]) {
+      throw new AstroError({
+        ...ResponseSentError
+      });
+    }
+  }
+  /**
+   * Astro.cookies.header() returns an iterator for the cookies that have previously
+   * been set by either Astro.cookies.set() or Astro.cookies.delete().
+   * This method is primarily used by adapters to set the header on outgoing responses.
+   * @returns
+   */
+  *headers() {
+    if (this.#outgoing == null)
+      return;
+    for (const [, value] of this.#outgoing) {
+      yield value[1];
+    }
+  }
+  #ensureParsed() {
+    if (!this.#requestValues) {
+      this.#parse();
+    }
+    if (!this.#requestValues) {
+      this.#requestValues = {};
+    }
+    return this.#requestValues;
+  }
+  #ensureOutgoingMap() {
+    if (!this.#outgoing) {
+      this.#outgoing = /* @__PURE__ */ new Map();
+    }
+    return this.#outgoing;
+  }
+  #parse() {
+    const raw = this.#request.headers.get("cookie");
+    if (!raw) {
+      return;
+    }
+    this.#requestValues = parse(raw);
+  }
+}
+
+const astroCookiesSymbol = Symbol.for("astro.cookies");
+function attachCookiesToResponse(response, cookies) {
+  Reflect.set(response, astroCookiesSymbol, cookies);
+}
+function getFromResponse(response) {
+  let cookies = Reflect.get(response, astroCookiesSymbol);
+  if (cookies != null) {
+    return cookies;
+  } else {
+    return void 0;
+  }
+}
+function* getSetCookiesFromResponse(response) {
+  const cookies = getFromResponse(response);
+  if (!cookies) {
+    return [];
+  }
+  for (const headerValue of cookies.headers()) {
+    yield headerValue;
+  }
+  return [];
+}
+
+const dateTimeFormat = new Intl.DateTimeFormat([], {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit"
+});
+const levels = {
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  silent: 90
+};
+function log(opts, level, label, message) {
+  const logLevel = opts.level;
+  const dest = opts.dest;
+  const event = {
+    label,
+    level,
+    message
+  };
+  if (levels[logLevel] > levels[level]) {
+    return;
+  }
+  dest.write(event);
+}
+function info(opts, label, message) {
+  return log(opts, "info", label, message);
+}
+function warn(opts, label, message) {
+  return log(opts, "warn", label, message);
+}
+function error(opts, label, message) {
+  return log(opts, "error", label, message);
+}
+function debug(...args) {
+  if ("_astroGlobalDebug" in globalThis) {
+    globalThis._astroGlobalDebug(...args);
+  }
+}
+if (typeof process !== "undefined") {
+  let proc = process;
+  if ("argv" in proc && Array.isArray(proc.argv)) {
+    if (proc.argv.includes("--verbose")) ; else if (proc.argv.includes("--silent")) ; else ;
+  }
+}
+class Logger {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  info(label, message) {
+    info(this.options, label, message);
+  }
+  warn(label, message) {
+    warn(this.options, label, message);
+  }
+  error(label, message) {
+    error(this.options, label, message);
+  }
+  debug(label, message, ...args) {
+    debug(this.options, label, message, args);
+  }
+  level() {
+    return this.options.level;
+  }
+  forkIntegrationLogger(label) {
+    return new AstroIntegrationLogger(this.options, label);
+  }
+}
+class AstroIntegrationLogger {
+  options;
+  label;
+  constructor(logging, label) {
+    this.options = logging;
+    this.label = label;
+  }
+  /**
+   * Creates a new logger instance with a new label, but the same log options.
+   */
+  fork(label) {
+    return new AstroIntegrationLogger(this.options, label);
+  }
+  info(message) {
+    info(this.options, this.label, message);
+  }
+  warn(message) {
+    warn(this.options, this.label, message);
+  }
+  error(message) {
+    error(this.options, this.label, message);
+  }
+  debug(message) {
+    debug(this.options, this.label, message);
+  }
+}
+
+async function callMiddleware(logger, onRequest, apiContext, responseFunction) {
+  let nextCalled = false;
+  let responseFunctionPromise = void 0;
+  const next = async () => {
+    nextCalled = true;
+    responseFunctionPromise = responseFunction();
+    return responseFunctionPromise;
+  };
+  let middlewarePromise = onRequest(apiContext, next);
+  return await Promise.resolve(middlewarePromise).then(async (value) => {
+    if (isEndpointOutput(value)) {
+      logger.warn(
+        "middleware",
+        `Using simple endpoints can cause unexpected issues in the chain of middleware functions.
+It's strongly suggested to use full ${bold("Response")} objects.`
+      );
+    }
+    if (nextCalled) {
+      if (typeof value !== "undefined") {
+        if (value instanceof Response === false) {
+          throw new AstroError(MiddlewareNotAResponse);
+        }
+        return value;
+      } else {
+        if (responseFunctionPromise) {
+          return responseFunctionPromise;
+        } else {
+          throw new AstroError(MiddlewareNotAResponse);
+        }
+      }
+    } else if (typeof value === "undefined") {
+      throw new AstroError(MiddlewareNoDataOrNextCalled);
+    } else if (value instanceof Response === false) {
+      throw new AstroError(MiddlewareNotAResponse);
+    } else {
+      return value;
+    }
+  });
+}
+function isEndpointOutput(endpointResult) {
+  return !(endpointResult instanceof Response) && typeof endpointResult === "object" && typeof endpointResult.body === "string";
+}
+
+const encoder = new TextEncoder();
+const clientAddressSymbol = Symbol.for("astro.clientAddress");
+const clientLocalsSymbol = Symbol.for("astro.locals");
+function createAPIContext({
+  request,
+  params,
+  site,
+  props,
+  adapterName
+}) {
+  initResponseWithEncoding();
+  const context = {
+    cookies: new AstroCookies(request),
+    request,
+    params,
+    site: site ? new URL(site) : void 0,
+    generator: `Astro v${ASTRO_VERSION}`,
+    props,
+    redirect(path, status) {
+      return new Response(null, {
+        status: status || 302,
+        headers: {
+          Location: path
+        }
+      });
+    },
+    ResponseWithEncoding,
+    url: new URL(request.url),
+    get clientAddress() {
+      if (!(clientAddressSymbol in request)) {
+        if (adapterName) {
+          throw new AstroError({
+            ...ClientAddressNotAvailable,
+            message: ClientAddressNotAvailable.message(adapterName)
+          });
+        } else {
+          throw new AstroError(StaticClientAddressNotAvailable);
+        }
+      }
+      return Reflect.get(request, clientAddressSymbol);
+    }
+  };
+  Object.defineProperty(context, "locals", {
+    enumerable: true,
+    get() {
+      return Reflect.get(request, clientLocalsSymbol);
+    },
+    set(val) {
+      if (typeof val !== "object") {
+        throw new AstroError(LocalsNotAnObject);
+      } else {
+        Reflect.set(request, clientLocalsSymbol, val);
+      }
+    }
+  });
+  return context;
+}
+let ResponseWithEncoding;
+let initResponseWithEncoding = () => {
+  class LocalResponseWithEncoding extends Response {
+    constructor(body, init, encoding) {
+      if (typeof body === "string") {
+        if (typeof Buffer !== "undefined" && Buffer.from) {
+          body = Buffer.from(body, encoding);
+        } else if (encoding == null || encoding === "utf8" || encoding === "utf-8") {
+          body = encoder.encode(body);
+        }
+      }
+      super(body, init);
+      if (encoding) {
+        this.headers.set("X-Astro-Encoding", encoding);
+      }
+    }
+  }
+  ResponseWithEncoding = LocalResponseWithEncoding;
+  initResponseWithEncoding = () => {
+  };
+  return LocalResponseWithEncoding;
+};
+async function callEndpoint(mod, env, ctx, onRequest) {
+  const context = createAPIContext({
+    request: ctx.request,
+    params: ctx.params,
+    props: ctx.props,
+    site: env.site,
+    adapterName: env.adapterName
+  });
+  let response;
+  if (onRequest) {
+    response = await callMiddleware(
+      env.logger,
+      onRequest,
+      context,
+      async () => {
+        return await renderEndpoint(mod, context, env.ssr, env.logger);
+      }
+    );
+  } else {
+    response = await renderEndpoint(mod, context, env.ssr, env.logger);
+  }
+  const isEndpointSSR = env.ssr && !ctx.route?.prerender;
+  if (response instanceof Response) {
+    if (isEndpointSSR && response.headers.get("X-Astro-Encoding")) {
+      env.logger.warn(
+        "ssr",
+        "`ResponseWithEncoding` is ignored in SSR. Please return an instance of Response. See https://docs.astro.build/en/core-concepts/endpoints/#server-endpoints-api-routes for more information."
+      );
+    }
+    attachCookiesToResponse(response, context.cookies);
+    return response;
+  }
+  env.logger.warn(
+    "astro",
+    `${ctx.route.component} returns a simple object which is deprecated. Please return an instance of Response. See https://docs.astro.build/en/core-concepts/endpoints/#server-endpoints-api-routes for more information.`
+  );
+  if (isEndpointSSR) {
+    if (response.hasOwnProperty("headers")) {
+      env.logger.warn(
+        "ssr",
+        "Setting headers is not supported when returning an object. Please return an instance of Response. See https://docs.astro.build/en/core-concepts/endpoints/#server-endpoints-api-routes for more information."
+      );
+    }
+    if (response.encoding) {
+      env.logger.warn(
+        "ssr",
+        "`encoding` is ignored in SSR. To return a charset other than UTF-8, please return an instance of Response. See https://docs.astro.build/en/core-concepts/endpoints/#server-endpoints-api-routes for more information."
+      );
+    }
+  }
+  let body;
+  const headers = new Headers();
+  const pathname = ctx.route ? (
+    // Try the static route `pathname`
+    ctx.route.pathname ?? // Dynamic routes don't include `pathname`, so synthesize a path for these (e.g. 'src/pages/[slug].svg')
+    ctx.route.segments.map((s) => s.map((p) => p.content).join("")).join("/")
+  ) : (
+    // Fallback to pathname of the request
+    ctx.pathname
+  );
+  const mimeType = mime.getType(pathname) || "text/plain";
+  headers.set("Content-Type", `${mimeType};charset=utf-8`);
+  if (response.encoding) {
+    headers.set("X-Astro-Encoding", response.encoding);
+  }
+  if (response.body instanceof Uint8Array) {
+    body = response.body;
+    headers.set("Content-Length", body.byteLength.toString());
+  } else if (typeof Buffer !== "undefined" && Buffer.from) {
+    body = Buffer.from(response.body, response.encoding);
+    headers.set("Content-Length", body.byteLength.toString());
+  } else if (response.encoding == null || response.encoding === "utf8" || response.encoding === "utf-8") {
+    body = encoder.encode(response.body);
+    headers.set("Content-Length", body.byteLength.toString());
+  } else {
+    body = response.body;
+  }
+  response = new Response(body, {
+    status: 200,
+    headers
+  });
+  attachCookiesToResponse(response, context.cookies);
+  return response;
+}
+
+function getRouteGenerator(segments, addTrailingSlash) {
+  const template = segments.map((segment) => {
+    return "/" + segment.map((part) => {
+      if (part.spread) {
+        return `:${part.content.slice(3)}(.*)?`;
+      } else if (part.dynamic) {
+        return `:${part.content}`;
+      } else {
+        return part.content.normalize().replace(/\?/g, "%3F").replace(/#/g, "%23").replace(/%5B/g, "[").replace(/%5D/g, "]").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      }
+    }).join("");
+  }).join("");
+  let trailing = "";
+  if (addTrailingSlash === "always" && segments.length) {
+    trailing = "/";
+  }
+  const toPath = compile(template + trailing);
+  return toPath;
+}
+
+function deserializeRouteData(rawRouteData) {
+  return {
+    route: rawRouteData.route,
+    type: rawRouteData.type,
+    pattern: new RegExp(rawRouteData.pattern),
+    params: rawRouteData.params,
+    component: rawRouteData.component,
+    generate: getRouteGenerator(rawRouteData.segments, rawRouteData._meta.trailingSlash),
+    pathname: rawRouteData.pathname || void 0,
+    segments: rawRouteData.segments,
+    prerender: rawRouteData.prerender,
+    redirect: rawRouteData.redirect,
+    redirectRoute: rawRouteData.redirectRoute ? deserializeRouteData(rawRouteData.redirectRoute) : void 0
+  };
+}
+
+function deserializeManifest(serializedManifest) {
+  const routes = [];
+  for (const serializedRoute of serializedManifest.routes) {
+    routes.push({
+      ...serializedRoute,
+      routeData: deserializeRouteData(serializedRoute.routeData)
+    });
+    const route = serializedRoute;
+    route.routeData = deserializeRouteData(serializedRoute.routeData);
+  }
+  const assets = new Set(serializedManifest.assets);
+  const componentMetadata = new Map(serializedManifest.componentMetadata);
+  const clientDirectives = new Map(serializedManifest.clientDirectives);
+  return {
+    ...serializedManifest,
+    assets,
+    componentMetadata,
+    clientDirectives,
+    routes
+  };
+}
+
+const manifest = deserializeManifest({"adapterName":"@astrojs/node","routes":[{"file":"","links":[],"scripts":[],"styles":[],"routeData":{"type":"endpoint","route":"/_image","pattern":"^\\/_image$","segments":[[{"content":"_image","dynamic":false,"spread":false}]],"params":[],"component":"../../node_modules/.pnpm/astro@3.0.5/node_modules/astro/dist/assets/image-endpoint.js","pathname":"/_image","prerender":false,"_meta":{"trailingSlash":"ignore"}}},{"file":"","links":[],"scripts":[{"type":"external","value":"/_astro/hoisted.d90361ee.js"}],"styles":[{"type":"external","src":"/_astro/_...slug_.b693913e.css"}],"routeData":{"route":"/","type":"page","pattern":"^\\/$","segments":[],"params":[],"component":"src/pages/index.astro","pathname":"/","prerender":false,"_meta":{"trailingSlash":"ignore"}}},{"file":"","links":[],"scripts":[{"type":"external","value":"/_astro/hoisted.d90361ee.js"}],"styles":[{"type":"external","src":"/_astro/_...slug_.b693913e.css"}],"routeData":{"route":"/~fallback","type":"page","pattern":"^\\/~fallback\\/?$","segments":[[{"content":"~fallback","dynamic":false,"spread":false}]],"params":[],"component":"src/pages/~fallback.astro","pathname":"/~fallback","prerender":false,"_meta":{"trailingSlash":"ignore"}}},{"file":"","links":[],"scripts":[],"styles":[],"routeData":{"route":"/app","type":"page","pattern":"^\\/app\\/?$","segments":[[{"content":"app","dynamic":false,"spread":false}]],"params":[],"component":"src/pages/app/index.astro","pathname":"/app","prerender":false,"_meta":{"trailingSlash":"ignore"}}},{"file":"","links":[],"scripts":[],"styles":[],"routeData":{"route":"/app/account","type":"page","pattern":"^\\/app\\/account\\/?$","segments":[[{"content":"app","dynamic":false,"spread":false}],[{"content":"account","dynamic":false,"spread":false}]],"params":[],"component":"src/pages/app/account.astro","pathname":"/app/account","prerender":false,"_meta":{"trailingSlash":"ignore"}}},{"file":"","links":[],"scripts":[{"type":"external","value":"/_astro/hoisted.d90361ee.js"}],"styles":[{"type":"external","src":"/_astro/_...slug_.b693913e.css"}],"routeData":{"route":"/[...slug]","type":"page","pattern":"^(?:\\/(.*?))?\\/?$","segments":[[{"content":"...slug","dynamic":true,"spread":true}]],"params":["...slug"],"component":"src/pages/[...slug].astro","prerender":false,"_meta":{"trailingSlash":"ignore"}}}],"site":"https://ecom2-demo.web.app","base":"/","compressHTML":false,"componentMetadata":[],"renderers":[],"clientDirectives":[["idle","(()=>{var i=t=>{let e=async()=>{await(await t())()};\"requestIdleCallback\"in window?window.requestIdleCallback(e):setTimeout(e,200)};(self.Astro||(self.Astro={})).idle=i;window.dispatchEvent(new Event(\"astro:idle\"));})();"],["load","(()=>{var e=async t=>{await(await t())()};(self.Astro||(self.Astro={})).load=e;window.dispatchEvent(new Event(\"astro:load\"));})();"],["media","(()=>{var s=(i,t)=>{let a=async()=>{await(await i())()};if(t.value){let e=matchMedia(t.value);e.matches?a():e.addEventListener(\"change\",a,{once:!0})}};(self.Astro||(self.Astro={})).media=s;window.dispatchEvent(new Event(\"astro:media\"));})();"],["only","(()=>{var e=async t=>{await(await t())()};(self.Astro||(self.Astro={})).only=e;window.dispatchEvent(new Event(\"astro:only\"));})();"],["visible","(()=>{var r=(i,c,n)=>{let s=async()=>{await(await i())()},t=new IntersectionObserver(e=>{for(let o of e)if(o.isIntersecting){t.disconnect(),s();break}});for(let e of n.children)t.observe(e)};(self.Astro||(self.Astro={})).visible=r;window.dispatchEvent(new Event(\"astro:visible\"));})();"]],"entryModules":{"\u0000@astrojs-ssr-virtual-entry":"entry.mjs","\u0000@astro-renderers":"renderers.mjs","\u0000empty-middleware":"_empty-middleware.mjs","/src/pages/app/account.astro":"chunks/pages/account.astro.f11f26f3.mjs","/../../node_modules/.pnpm/astro@3.0.5/node_modules/astro/dist/assets/image-endpoint.js":"chunks/pages/image-endpoint.js.a9374d3e.mjs","/src/pages/~fallback.astro":"chunks/pages/~fallback.astro.01594623.mjs","\u0000@astrojs-manifest":"manifest.12e7a10c.mjs","\u0000@astro-page:../../node_modules/.pnpm/astro@3.0.5/node_modules/astro/dist/assets/image-endpoint@_@js":"chunks/image-endpoint@_@js.802bf648.mjs","\u0000@astro-page:src/pages/index@_@astro":"chunks/index@_@astro.a122f091.mjs","\u0000@astro-page:src/pages/~fallback@_@astro":"chunks/~fallback@_@astro.876a97c5.mjs","\u0000@astro-page:src/pages/app/index@_@astro":"chunks/index@_@astro.da98dcbe.mjs","\u0000@astro-page:src/pages/app/account@_@astro":"chunks/account@_@astro.fa8b921b.mjs","\u0000@astro-page:src/pages/[...slug]@_@astro":"chunks/_...f7cdc954.mjs","/home/leo/code/ecomplus/cloud-commerce/packages/storefront/node_modules/astro/dist/assets/services/sharp.js":"chunks/sharp.52841bb4.mjs","/home/leo/code/ecomplus/cloud-commerce/packages/storefront/src/components/SearchModal.vue":"_astro/SearchModal.117a477d.js","/home/leo/code/ecomplus/cloud-commerce/packages/storefront/src/components/CartSidebar.vue":"_astro/CartSidebar.2731d333.js","@astrojs/vue/client.js":"_astro/client.a5d2898b.js","/home/leo/code/ecomplus/cloud-commerce/node_modules/workbox-window/build/workbox-window.prod.es5.mjs":"_astro/workbox-window.prod.es5.a7b12eab.js","~/components/HeroSlider.vue":"_astro/HeroSlider.a70b2582.js","~/components/ProductShelf.vue":"_astro/ProductShelf.619c56a5.js","/astro/hoisted.js?q=0":"_astro/hoisted.d90361ee.js","~/components/PitchBar.vue":"_astro/PitchBar.13991988.js","~/components/ShopHeader.vue":"_astro/ShopHeader.d50a07c1.js","/home/leo/code/ecomplus/cloud-commerce/packages/storefront/src/lib/scripts/firebase-app.ts":"_astro/firebase-app.93857bfb.js","astro:scripts/before-hydration.js":""},"assets":["/_astro/_...slug_.b693913e.css","/manifest.webmanifest","/robots.txt","/sw.js","/workbox-5e0bf4e4.js","/_astro/Carousel.0b24e2cb.js","/_astro/CartSidebar.2731d333.js","/_astro/HeroSlider.a70b2582.js","/_astro/PitchBar.13991988.js","/_astro/Prices.cdfa346a.js","/_astro/ProductShelf.619c56a5.js","/_astro/SearchModal.117a477d.js","/_astro/ShopHeader.d50a07c1.js","/_astro/_plugin-vue_export-helper.fc5e2f5b.js","/_astro/api.39f40cd8.js","/_astro/client.a5d2898b.js","/_astro/firebase-app.93857bfb.js","/_astro/format-money.86f14860.js","/_astro/hoisted.d90361ee.js","/_astro/img.d4891d80.js","/_astro/index.33801818.js","/_astro/modules-info.ec412b24.js","/_astro/preload-helper.cf010ec4.js","/_astro/session-utm.744b0db3.js","/_astro/workbox-window.prod.es5.a7b12eab.js","/img/icon.png","/img/large-icon.png","/img/uploads/banner2.webp","/img/uploads/ecom-icon.png","/img/uploads/headphone.webp","/img/uploads/logo.png","/img/uploads/og-image.png","/img/uploads/passion.webp","/img/uploads/rect8589.png","/img/uploads/rect859.png","/img/uploads/rect89.webp"]});
+
+export { AstroCookies as A, Logger as L, attachCookiesToResponse as a, callEndpoint as b, createAPIContext as c, dateTimeFormat as d, callMiddleware as e, AstroIntegrationLogger as f, getSetCookiesFromResponse as g, levels as l, manifest };

package/packages/storefront/dist/server/renderers.mjs

@@ -1,31 +1,20 @@
-import { i as server_default } from './chunks/astro.bb5b7191.mjs';
 import { useSSRContext, defineComponent, computed, createVNode, resolveDynamicComponent, mergeProps, withCtx, renderSlot, h, createSSRApp } from 'vue';
 import { ssrRenderSlotInner, ssrRenderVNode, ssrRenderSlot, ssrRenderAttrs, ssrRenderClass, renderToString } from 'vue/server-renderer';
 import { img, imgSizes, i18n, formatMoney } from '@ecomplus/utils';
-import { _ as _export_sfc } from './chunks/pages/_...slug_.astro.fd8a229f.mjs';
-import 'path-to-regexp';
-import 'cookie';
+import { _ as _export_sfc } from './chunks/pages/_...slug_.astro.08ba5973.mjs';
 import '@astrojs/internal-helpers/path';
-import 'kleur/colors';
-import 'node:fs';
-import 'node:http';
-import 'node:tls';
-import 'mime';
-import 'string-width';
+import './chunks/astro.440a2e08.mjs';
+import 'clsx';
 import 'html-escaper';
-import 'node:fs/promises';
-import 'node:path';
-import 'node:url';
-import 'http-cache-semantics';
-import 'node:os';
-import 'image-size';
-import 'magic-string';
-import 'node:stream';
 import '@cloudcommerce/api';
 import 'node:events';
+import 'node:fs';
+import 'node:path';
 import '@cloudcommerce/config';
 import 'ultrahtml';
-/* empty css                                     */import '@vueuse/core';
+/* empty css                                     */import 'image-size';
+import 'mime';
+import '@vueuse/core';
 import '@headlessui/vue';
 
 const _sfc_main$3 = /* @__PURE__ */ defineComponent({
@@ -370,12 +359,12 @@ async function renderToStaticMarkup(Component, props, slotted, metadata) {
 	return { html };
 }
 
-const _renderer1 = {
+const _renderer0 = {
 	check,
 	renderToStaticMarkup,
 	supportsAstroStaticSlot: true,
 };
 
-const renderers = [Object.assign({"name":"astro:jsx","serverEntrypoint":"astro/jsx/server.js","jsxImportSource":"astro"}, { ssr: server_default }),Object.assign({"name":"@astrojs/vue","clientEntrypoint":"@astrojs/vue/client.js","serverEntrypoint":"@astrojs/vue/server.js"}, { ssr: _renderer1 }),];
+const renderers = [Object.assign({"name":"@astrojs/vue","clientEntrypoint":"@astrojs/vue/client.js","serverEntrypoint":"@astrojs/vue/server.js"}, { ssr: _renderer0 }),];
 
 export { renderers };

package/packages/storefront/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloudcommerce/storefront",
   "type": "module",
-  "version": "0.26.2",
+  "version": "0.26.3",
   "description": "E-Com Plus Cloud Commerce storefront with Astro",
   "bin": {
     "storefront": "./scripts/build-prod.sh"
@@ -40,20 +40,20 @@
     "@headlessui/vue": "^1.7.16",
     "@iconify-json/fa6-brands": "^1.1.13",
     "@iconify-json/heroicons": "^1.1.12",
-    "@iconify-json/logos": "^1.1.34",
-    "@vite-pwa/astro": "^0.1.1",
+    "@iconify-json/logos": "^1.1.35",
+    "@vite-pwa/astro": "^0.1.2",
     "@vueuse/core": "10.4.1",
-    "astro": "2.10.14",
+    "astro": "2.10.15",
     "astro-capo": "^0.0.1",
     "chroma-js": "^2.4.2",
     "dotenv": "^16.3.1",
-    "firebase": "^10.3.0",
+    "firebase": "^10.3.1",
     "image-size": "^1.0.2",
     "mime": "^3.0.0",
     "semver": "^7.5.4",
     "sharp": "^0.32.5",
     "tailwindcss": "^3.3.3",
-    "unocss": "^0.55.3",
+    "unocss": "^0.55.7",
     "vite": "^4.4.9",
     "vite-plugin-pwa": "^0.16.4",
     "vue": "^3.3.4"

package/packages/storefront/src/lib/layouts/BaseHead.astro

@@ -29,7 +29,7 @@ if (fetchingApiContext) {
 
 const apiDoc = apiContext.doc;
 const state: Record<string, any> = apiDoc || cmsContent || {};
-const title = state.meta_title || state.name || state.title || Astro.props.title || settings.name;
+const title = state.meta_title || state.name || state.title || settings.name;
 const description = state.meta_description || state.short_description || settings.description;
 const favicon = settings.icon ? getIconUrl(32) : '/favicon.ico';
 const shortcutIcon = settings.icon ? getIconUrl(192) : null;
@@ -137,9 +137,10 @@ const inlineJSONLd = JSON.stringify({
 {metatagsContent?.twitter_username &&
   <meta name="twitter:site" content={metatagsContent.twitter_username} />}
 <meta name="ecom-store-id" content={String(storeId)}>
+
 <script>
   import { registerSW } from 'virtual:pwa-register';
-  registerSW({ immediate: true });
+  registerSW({ immediate: false });
 </script>
 {pwaInfo && <Fragment set:html={pwaInfo.webManifest.linkTag} />}
 {(!pwaInfo && !import.meta.env.DEV) &&