@wix/astro 2.18.0 → 2.19.0

package/build/dependencies/astro-auth/backend-runtime/{chunk-IUZYED2S.js → chunk-4UEBUUCA.js}

@@ -1,14 +1,14 @@
+import {
+  authAsyncLocalStorage,
+  createHost
+} from "./chunk-USQSPPTM.js";
+
 // src/runtime/backend/contextualClient.ts
 import { createClient, OAuthStrategy } from "@wix/sdk";
 import { WIX_CLIENT_ID } from "astro:env/client";
 
-// src/utils/authAsyncLocalStorage.ts
-import { AsyncLocalStorage } from "async_hooks";
-var authAsyncLocalStorage = new AsyncLocalStorage();
-
 // src/runtime/backend/hostProxy.ts
-import { headlessNode } from "@wix/headless-node";
-var defaultHost = headlessNode.host({});
+var defaultHost = createHost();
 var resolveHostForCurrentRequest = () => {
   const store = authAsyncLocalStorage.getStore();
   return store?.sdkHost ?? defaultHost;
@@ -81,10 +81,7 @@ var elevatedContextualClient = createClient2({
   host: hostProxy
 });
 
-// src/runtime/backend/setupContextualClient.ts
-contextualClient.enableContext("module");
-elevatedContextualClient.enableContext("module", { elevated: true });
-
 export {
-  authAsyncLocalStorage
+  contextualClient,
+  elevatedContextualClient
 };

package/build/dependencies/astro-auth/backend-runtime/chunk-USQSPPTM.js

@@ -0,0 +1,14 @@
+// src/utils/authAsyncLocalStorage.ts
+import { AsyncLocalStorage } from "async_hooks";
+var authAsyncLocalStorage = new AsyncLocalStorage();
+
+// src/utils/host-utils.ts
+import { headlessNode } from "@wix/headless-node";
+function createHost(request, essentials) {
+  return headlessNode.host({ essentials, req: request });
+}
+
+export {
+  authAsyncLocalStorage,
+  createHost
+};

package/build/dependencies/astro-auth/backend-runtime/middleware/auth.js

@@ -2,13 +2,15 @@ import {
   saveSessionTokensToCookie
 } from "../chunk-HPW4ZAEJ.js";
 import {
-  authAsyncLocalStorage
-} from "../chunk-IUZYED2S.js";
+  contextualClient,
+  elevatedContextualClient
+} from "../chunk-4UEBUUCA.js";
+import {
+  authAsyncLocalStorage,
+  createHost
+} from "../chunk-USQSPPTM.js";
 import "../chunk-MLKGABMK.js";
 
-// src/middleware/auth.ts
-import { headlessNode } from "@wix/headless-node";
-
 // src/utils/generateVisitorTokens.ts
 import { OAuthStrategy } from "@wix/sdk";
 import { WIX_CLIENT_ID } from "astro:env/client";
@@ -50,6 +52,8 @@ function getSessionTokensFromCookie(context) {
 }
 
 // src/middleware/auth.ts
+contextualClient.enableContext("module");
+elevatedContextualClient.enableContext("module", { elevated: true });
 var onRequest = async (context, next) => {
   if (context.url.pathname.startsWith("/_wix/extensions/")) {
     return next();
@@ -57,24 +61,17 @@ var onRequest = async (context, next) => {
   const existingTokens = getExistingTokens(context);
   const usedTokens = existingTokens ?? await generateVisitorTokens();
   const store = {
-    sdkHost: headlessNode.host({ req: context.request }),
+    sdkHost: createHost(context.request),
     sessionTokens: usedTokens
   };
-  const response = await authAsyncLocalStorage.run(store, async () => {
+  const acceptHeader = context.request.headers.get("Accept");
+  const isStandardBrowserRequest = acceptHeader?.includes("text/html");
+  if (!context.isPrerendered && existingTokens !== usedTokens && isStandardBrowserRequest) {
+    saveSessionTokensToCookie(context, usedTokens);
+  }
+  return await authAsyncLocalStorage.run(store, async () => {
     return next();
   });
-  const contentType = response.headers.get("Content-Type");
-  if (contentType !== "text/html") {
-    return response;
-  }
-  if (context.isPrerendered) {
-    return response;
-  }
-  if (existingTokens === usedTokens) {
-    return response;
-  }
-  saveSessionTokensToCookie(context, usedTokens);
-  return response;
 };
 function getExistingTokens(context) {
   const existingTokens = getSessionTokensFromCookie(context);

package/build/dependencies/astro-auth/backend-runtime/middleware/localization.d.ts

@@ -0,0 +1,5 @@
+import { MiddlewareHandler } from 'astro';
+
+declare const onRequest: MiddlewareHandler;
+
+export { onRequest };

package/build/dependencies/astro-auth/backend-runtime/middleware/localization.js

@@ -0,0 +1,219 @@
+import {
+  authAsyncLocalStorage,
+  createHost
+} from "../chunk-USQSPPTM.js";
+import "../chunk-MLKGABMK.js";
+
+// ../request-transform-utils/src/transformStreamUtils.ts
+function injectBeforeTransformStream(predicate, htmlToInject) {
+  let hasInjected = false;
+  return new TransformStream({
+    transform: (chunk, controller) => {
+      if (!hasInjected) {
+        const index = chunk.indexOf(predicate);
+        if (index > -1) {
+          chunk = chunk.slice(0, index) + htmlToInject + chunk.slice(index);
+          hasInjected = true;
+        }
+      }
+      controller.enqueue(chunk);
+    }
+  });
+}
+
+// ../request-transform-utils/src/index.ts
+var headTransformStream = (htmlToInject) => injectBeforeTransformStream("</head>", htmlToInject);
+
+// ../../node_modules/outdent/lib-module/index.js
+function noop() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+}
+function createWeakMap() {
+  if (typeof WeakMap !== "undefined") {
+    return /* @__PURE__ */ new WeakMap();
+  } else {
+    return fakeSetOrMap();
+  }
+}
+function fakeSetOrMap() {
+  return {
+    add: noop,
+    delete: noop,
+    get: noop,
+    set: noop,
+    has: function(k) {
+      return false;
+    }
+  };
+}
+var hop = Object.prototype.hasOwnProperty;
+var has = function(obj, prop) {
+  return hop.call(obj, prop);
+};
+function extend(target, source) {
+  for (var prop in source) {
+    if (has(source, prop)) {
+      target[prop] = source[prop];
+    }
+  }
+  return target;
+}
+var reLeadingNewline = /^[ \t]*(?:\r\n|\r|\n)/;
+var reTrailingNewline = /(?:\r\n|\r|\n)[ \t]*$/;
+var reStartsWithNewlineOrIsEmpty = /^(?:[\r\n]|$)/;
+var reDetectIndentation = /(?:\r\n|\r|\n)([ \t]*)(?:[^ \t\r\n]|$)/;
+var reOnlyWhitespaceWithAtLeastOneNewline = /^[ \t]*[\r\n][ \t\r\n]*$/;
+function _outdentArray(strings, firstInterpolatedValueSetsIndentationLevel, options) {
+  var indentationLevel = 0;
+  var match = strings[0].match(reDetectIndentation);
+  if (match) {
+    indentationLevel = match[1].length;
+  }
+  var reSource = "(\\r\\n|\\r|\\n).{0," + indentationLevel + "}";
+  var reMatchIndent = new RegExp(reSource, "g");
+  if (firstInterpolatedValueSetsIndentationLevel) {
+    strings = strings.slice(1);
+  }
+  var newline = options.newline, trimLeadingNewline = options.trimLeadingNewline, trimTrailingNewline = options.trimTrailingNewline;
+  var normalizeNewlines = typeof newline === "string";
+  var l = strings.length;
+  var outdentedStrings = strings.map(function(v, i) {
+    v = v.replace(reMatchIndent, "$1");
+    if (i === 0 && trimLeadingNewline) {
+      v = v.replace(reLeadingNewline, "");
+    }
+    if (i === l - 1 && trimTrailingNewline) {
+      v = v.replace(reTrailingNewline, "");
+    }
+    if (normalizeNewlines) {
+      v = v.replace(/\r\n|\n|\r/g, function(_) {
+        return newline;
+      });
+    }
+    return v;
+  });
+  return outdentedStrings;
+}
+function concatStringsAndValues(strings, values) {
+  var ret = "";
+  for (var i = 0, l = strings.length; i < l; i++) {
+    ret += strings[i];
+    if (i < l - 1) {
+      ret += values[i];
+    }
+  }
+  return ret;
+}
+function isTemplateStringsArray(v) {
+  return has(v, "raw") && has(v, "length");
+}
+function createInstance(options) {
+  var arrayAutoIndentCache = createWeakMap();
+  var arrayFirstInterpSetsIndentCache = createWeakMap();
+  function outdent(stringsOrOptions) {
+    var values = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+      values[_i - 1] = arguments[_i];
+    }
+    if (isTemplateStringsArray(stringsOrOptions)) {
+      var strings = stringsOrOptions;
+      var firstInterpolatedValueSetsIndentationLevel = (values[0] === outdent || values[0] === defaultOutdent) && reOnlyWhitespaceWithAtLeastOneNewline.test(strings[0]) && reStartsWithNewlineOrIsEmpty.test(strings[1]);
+      var cache = firstInterpolatedValueSetsIndentationLevel ? arrayFirstInterpSetsIndentCache : arrayAutoIndentCache;
+      var renderedArray = cache.get(strings);
+      if (!renderedArray) {
+        renderedArray = _outdentArray(strings, firstInterpolatedValueSetsIndentationLevel, options);
+        cache.set(strings, renderedArray);
+      }
+      if (values.length === 0) {
+        return renderedArray[0];
+      }
+      var rendered = concatStringsAndValues(renderedArray, firstInterpolatedValueSetsIndentationLevel ? values.slice(1) : values);
+      return rendered;
+    } else {
+      return createInstance(extend(extend({}, options), stringsOrOptions || {}));
+    }
+  }
+  var fullOutdent = extend(outdent, {
+    string: function(str) {
+      return _outdentArray([str], false, options)[0];
+    }
+  });
+  return fullOutdent;
+}
+var defaultOutdent = createInstance({
+  trimLeadingNewline: true,
+  trimTrailingNewline: true
+});
+if (typeof module !== "undefined") {
+  try {
+    module.exports = defaultOutdent;
+    Object.defineProperty(defaultOutdent, "__esModule", { value: true });
+    defaultOutdent.default = defaultOutdent;
+    defaultOutdent.outdent = defaultOutdent;
+  } catch (e) {
+  }
+}
+
+// src/utils/localizationUtils.ts
+import {
+  getLocalizationData as getLocalizationDataFromUtils,
+  MULTILINGUAL_COOKIE_HEADER_KEY
+} from "@wix/headless-localization-utils";
+import { scripts } from "@wix/headless-site-assets";
+async function getLocalizationData(context) {
+  return getLocalizationDataFromUtils(
+    context.url,
+    context.request.headers,
+    (await scripts.getSiteMetadata()).properties ?? {}
+  );
+}
+function setMultilingualCookie(context, language) {
+  if (context.cookies.get(MULTILINGUAL_COOKIE_HEADER_KEY)?.value !== language) {
+    context.cookies.set(MULTILINGUAL_COOKIE_HEADER_KEY, language, {
+      httpOnly: false,
+      path: "/",
+      sameSite: "lax"
+    });
+  }
+}
+
+// src/middleware/localization.ts
+var onRequest = async (context, next) => {
+  const store = authAsyncLocalStorage.getStore();
+  if (!store) {
+    return next();
+  }
+  let localizationData;
+  try {
+    localizationData = await getLocalizationData(context);
+  } catch {
+    return next();
+  }
+  const { cleanUrl, essentials } = localizationData;
+  if (essentials.language == null || essentials.multilingual === void 0) {
+    return next();
+  }
+  store.sdkHost = createHost(context.request, essentials);
+  setMultilingualCookie(context, essentials.language);
+  const nextResponse = cleanUrl !== context.url.href ? await next(cleanUrl) : await next();
+  return modifyHtmlEmbed(nextResponse, context, essentials);
+};
+function modifyHtmlEmbed(response, context, essentials) {
+  const contentType = response.headers.get("Content-Type");
+  if (contentType !== "text/html" || context.url.pathname.startsWith("/_wix") || !response.body) {
+    return response;
+  }
+  const essentialsScript = defaultOutdent`
+    <script>window.essentials = ${JSON.stringify(essentials)};</script>
+  `;
+  return new Response(
+    response.body.pipeThrough(new TextDecoderStream()).pipeThrough(headTransformStream(essentialsScript)).pipeThrough(new TextEncoderStream()),
+    response
+  );
+}
+export {
+  onRequest
+};

package/build/dependencies/astro-auth/backend-runtime/runtime/backend/setupContextualClient.js

@@ -1,2 +1,10 @@
-import "../../chunk-IUZYED2S.js";
+import {
+  contextualClient,
+  elevatedContextualClient
+} from "../../chunk-4UEBUUCA.js";
+import "../../chunk-USQSPPTM.js";
 import "../../chunk-MLKGABMK.js";
+
+// src/runtime/backend/setupContextualClient.ts
+contextualClient.enableContext("module");
+elevatedContextualClient.enableContext("module", { elevated: true });

package/build/dependencies/astro-backend-extensions/backend-runtime/chunk-CPGTXQVH.js

@@ -0,0 +1,75 @@
+// src/runtime/contextualClient.ts
+import { createClient } from "@wix/sdk";
+var elevateNeededError = new Error(
+  "Contextual client is not available for events and service plugins, please use elevate() instead."
+);
+var contextualClient = createClient({
+  auth: {
+    getActiveToken: () => {
+      throw elevateNeededError;
+    },
+    getAuthHeaders: async () => {
+      throw elevateNeededError;
+    }
+  }
+});
+
+// src/runtime/authAsyncLocalStorage.ts
+import { AsyncLocalStorage } from "async_hooks";
+var authAsyncLocalStorage = new AsyncLocalStorage();
+
+// src/runtime/elevatedContextualClient.ts
+import { createClient as createClient2 } from "@wix/sdk";
+var elevatedContextualClient = createClient2({
+  auth: {
+    getAuthHeaders: async (host) => {
+      const store = authAsyncLocalStorage.getStore();
+      if (!store) {
+        throw new Error("Cannot find an authentication strategy");
+      }
+      if (store.elevatedAuth) {
+        return store.elevatedAuth.getAuthHeaders(host);
+      }
+      throw new Error("Cannot find an elevated authentication strategy");
+    }
+  }
+});
+
+// src/runtime/utils.ts
+import { AppStrategy, createClient as createClient3 } from "@wix/sdk";
+import { wixContext } from "@wix/sdk-context";
+function createAppStrategy(opts = {}) {
+  return AppStrategy({
+    ...opts,
+    appId: import.meta.env.WIX_CLIENT_ID
+  });
+}
+async function setupClient(fn) {
+  let authOptions = {};
+  const client = createClient3({
+    auth: () => AppStrategy({
+      appId: import.meta.env.WIX_CLIENT_ID,
+      ...authOptions
+    })
+  });
+  const olderClient = wixContext.client;
+  client.enableContext("module");
+  await fn();
+  if (olderClient) {
+    olderClient.enableContext("module");
+  }
+  return {
+    client,
+    setAuthOptions: (options) => {
+      authOptions = options;
+    }
+  };
+}
+
+export {
+  contextualClient,
+  authAsyncLocalStorage,
+  elevatedContextualClient,
+  createAppStrategy,
+  setupClient
+};

package/build/dependencies/astro-backend-extensions/backend-runtime/routes/extensions.js

@@ -0,0 +1,41 @@
+// src/routes/extensions.ts
+import { WIX_CLIENT_PUBLIC_KEY, WIX_CLIENT_SECRET } from "astro:env/server";
+var authOptions = {
+  appSecret: WIX_CLIENT_SECRET,
+  publicKey: WIX_CLIENT_PUBLIC_KEY
+};
+var runExtension = await createServeExtensionRunner();
+var ALL = async (context) => {
+  const componentId = context.params.compId;
+  if (componentId == null) {
+    return new Response(null, { status: 404 });
+  }
+  try {
+    return await runExtension({
+      componentId,
+      payload: await context.request.text(),
+      url: context.request.url
+    });
+  } catch (error) {
+    return Response.json(error, { status: 500 });
+  }
+};
+async function createServeExtensionRunner() {
+  const { entries } = await import("@virtual/wix-backend-entries");
+  return async ({
+    componentId,
+    payload,
+    url
+  }) => {
+    const loadModule = entries[componentId];
+    if (loadModule == null) {
+      return new Response(null, { status: 404 });
+    }
+    const module = await loadModule();
+    const result = await module.default({ authOptions, payload, url });
+    return Response.json(result ?? null);
+  };
+}
+export {
+  ALL
+};

package/build/dependencies/astro-backend-extensions/backend-runtime/runtime/setupServicePlugin.d.ts

@@ -1,5 +1,10 @@
-import { APIRoute } from 'astro';
+import { A as AppStrategyOptions } from '../utils-B7jr2PES.js';
+import '@wix/sdk';
 
-declare function setupServicePlugin(fn: () => Promise<unknown>): Promise<APIRoute>;
+declare function setupServicePlugin(fn: () => Promise<unknown>): Promise<({ authOptions, payload, url, }: {
+    authOptions: AppStrategyOptions;
+    payload: string;
+    url: string;
+}) => Promise<unknown>>;
 
 export { setupServicePlugin };

package/build/dependencies/astro-backend-extensions/backend-runtime/runtime/setupServicePlugin.js

@@ -1,12 +1,33 @@
 import {
+  authAsyncLocalStorage,
+  contextualClient,
+  createAppStrategy,
+  elevatedContextualClient,
   setupClient
-} from "../chunk-F7JXR3EK.js";
+} from "../chunk-CPGTXQVH.js";
 
 // src/runtime/setupServicePlugin.ts
+contextualClient.enableContext("module");
+elevatedContextualClient.enableContext("module", { elevated: true });
 async function setupServicePlugin(fn) {
-  const client = await setupClient(fn);
-  return async function(context) {
-    return client.servicePlugins.processRequest(context.request);
+  const { client, setAuthOptions } = await setupClient(fn);
+  return async function({
+    authOptions,
+    payload,
+    url
+  }) {
+    setAuthOptions(authOptions);
+    const processedRequest = await client.servicePlugins.parseJWT(payload);
+    return authAsyncLocalStorage.run(
+      {
+        auth: null,
+        elevatedAuth: createAppStrategy({
+          instanceId: processedRequest.metadata.instanceId,
+          ...authOptions
+        })
+      },
+      async () => client.servicePlugins.executeHandler(processedRequest, url)
+    );
   };
 }
 export {

package/build/dependencies/astro-backend-extensions/backend-runtime/runtime/setupWebhook.d.ts

@@ -1,5 +1,9 @@
-import { APIRoute } from 'astro';
+import { A as AppStrategyOptions } from '../utils-B7jr2PES.js';
+import '@wix/sdk';
 
-declare function setupWebhook(fn: () => Promise<unknown>): Promise<APIRoute>;
+declare function setupWebhook(fn: () => Promise<unknown>): Promise<({ authOptions, payload, }: {
+    authOptions: AppStrategyOptions;
+    payload: string;
+}) => Promise<void>>;
 
 export { setupWebhook };

package/build/dependencies/astro-backend-extensions/backend-runtime/runtime/setupWebhook.js

@@ -1,13 +1,32 @@
 import {
+  authAsyncLocalStorage,
+  contextualClient,
+  createAppStrategy,
+  elevatedContextualClient,
   setupClient
-} from "../chunk-F7JXR3EK.js";
+} from "../chunk-CPGTXQVH.js";
 
 // src/runtime/setupWebhook.ts
+contextualClient.enableContext("module");
+elevatedContextualClient.enableContext("module", { elevated: true });
 async function setupWebhook(fn) {
-  const client = await setupClient(fn);
-  return async function(context) {
-    await client.webhooks.processRequest(context.request);
-    return new Response("OK");
+  const { client, setAuthOptions } = await setupClient(fn);
+  return async function({
+    authOptions,
+    payload
+  }) {
+    setAuthOptions(authOptions);
+    const processedRequest = await client.webhooks.parseJWT(payload);
+    return authAsyncLocalStorage.run(
+      {
+        auth: null,
+        elevatedAuth: createAppStrategy({
+          instanceId: processedRequest.instanceId,
+          ...authOptions
+        })
+      },
+      async () => client.webhooks.executeHandlers(processedRequest)
+    );
   };
 }
 export {

package/build/dependencies/astro-backend-extensions/backend-runtime/utils-B7jr2PES.d.ts

@@ -0,0 +1,5 @@
+import { AppStrategy } from '@wix/sdk';
+
+type AppStrategyOptions = Partial<Parameters<typeof AppStrategy>[0]>;
+
+export type { AppStrategyOptions as A };

package/build/dependencies/astro-context-providers-extensions/browser-runtime/hmr.js

@@ -0,0 +1,26 @@
+// ../astro-browser-runtime/src/hmr/react-component.tsx
+import React, { useEffect, useRef, useState } from "react";
+function createComponentHmrWrapper(OriginalComponent, hotData) {
+  return (props) => {
+    const [WrappedComponent, setComponent] = useState(
+      () => hotData.Component ?? OriginalComponent
+    );
+    const isMountedRef = useRef(false);
+    useEffect(() => {
+      isMountedRef.current = true;
+      hotData.setComponent = (NewComponent) => {
+        hotData.Component = NewComponent;
+        if (isMountedRef.current) {
+          setComponent(() => NewComponent);
+        }
+      };
+      return () => {
+        isMountedRef.current = false;
+      };
+    }, []);
+    return /* @__PURE__ */ React.createElement(WrappedComponent, { ...props });
+  };
+}
+export {
+  createComponentHmrWrapper
+};

package/build/dependencies/astro-context-providers-extensions/browser-runtime/sdk.js

@@ -0,0 +1,21 @@
+// ../astro-browser-runtime/src/sdk/site.ts
+import { createClient } from "@wix/sdk";
+import { site } from "@wix/site";
+var enableClient = (applicationId) => {
+  const host = site.host({ applicationId });
+  const auth = site.auth();
+  const wixClient = createClient({
+    auth,
+    host
+  });
+  wixClient.enableContext("module");
+  return auth.getAccessTokenInjector();
+};
+
+// src/runtime/sdk.ts
+function createContext() {
+  return enableClient(import.meta.env.WIX_CLIENT_ID);
+}
+export {
+  createContext
+};

package/build/dependencies/astro-context-providers-extensions/types/index.d.ts

@@ -0,0 +1,32 @@
+import { WixIntegration, BaseExtension } from '@wix/astro-core';
+
+declare const createIntegration: () => WixIntegration;
+
+interface ContextProvider extends BaseExtension {
+    type: 'ContextProvider';
+    options: Options;
+}
+interface Options {
+    id: string;
+    type: string;
+    context?: Record<string, unknown>;
+    data?: Record<string, unknown>;
+    resources: {
+        [key: string]: unknown;
+        client: {
+            [key: string]: unknown;
+            url: string;
+        };
+        contextSpecifier: {
+            [key: string]: unknown;
+            hook: string;
+        };
+        editor?: {
+            [key: string]: unknown;
+            url: string;
+        };
+    };
+}
+declare function contextProvider(options: Options): ContextProvider;
+
+export { contextProvider, createIntegration as default };

package/build/dependencies/astro-core/types/index.d.ts

@@ -74,11 +74,12 @@ interface IntegrationHooks {
     }) => Promise<void> | void;
     /**
      * Wrapper around `astro:build:setup`, called during `astro build`.
-     *
-     * Note: Applied only for `target: 'client'`.
      */
     'wix:build:setup': (options: {
         createExtensionViteConfig: CreateExtensionViteConfig;
+        target: 'client' | 'server';
+        updateConfig: (newConfig: InlineConfig) => void;
+        vite: InlineConfig;
     }) => Promise<void> | void;
 }
 type WixIntegration = AstroIntegration & {
@@ -93,7 +94,7 @@ declare const createIntegration: ({ integrations, }: {
 
 declare class App {
     private extensions;
-    use(extension: BaseExtension): this;
+    use(extension: BaseDevCenterComponent | BaseExtension): this;
 }
 declare function app(): App;