@wix/astro 2.25.0 → 2.26.0

package/build/dependencies/astro-translations/{chunk-YRKN4TFH.js → backend-runtime/middleware/static-translations.js}

@@ -1,3 +1,8 @@
+// src/middleware/static-translations.ts
+import { i18n } from "@wix/essentials";
+import { headTransformStream } from "@wix/request-transform-utils";
+import { multilingual } from "@wix/site";
+
 // ../../node_modules/outdent/lib-module/index.js
 function noop() {
   var args = [];
@@ -131,6 +136,33 @@ if (typeof module !== "undefined") {
   }
 }
 
+// src/middleware/static-translations.ts
+globalThis.__wix_translations__ = __WIX_ASTRO_I18N__.translations;
+var onRequest = async (context, next) => {
+  const response = await next();
+  const contentType = response.headers.get("Content-Type");
+  if (contentType !== "text/html" || context.url.pathname.startsWith("/_wix") || !response.body) {
+    return response;
+  }
+  const filteredTranslations = getFilteredTranslations();
+  const translationsScript = defaultOutdent`
+    <script>window.__wix_translations__ = ${JSON.stringify(filteredTranslations)};</script>
+  `;
+  return new Response(
+    response.body.pipeThrough(new TextDecoderStream()).pipeThrough(headTransformStream(translationsScript)).pipeThrough(new TextEncoderStream()),
+    response
+  );
+};
+function getFilteredTranslations() {
+  const allTranslations = globalThis.__wix_translations__ ?? {};
+  const pickLanguage = (lang) => lang != null && allTranslations[lang] ? { [lang]: allTranslations[lang] } : {};
+  const currentLanguage = i18n.getLanguage();
+  const primaryLanguage = multilingual.listSupportedLanguages().find((language) => language.primary)?.id;
+  return {
+    ...pickLanguage(currentLanguage),
+    ...pickLanguage(primaryLanguage)
+  };
+}
 export {
-  defaultOutdent
+  onRequest
 };

package/build/dependencies/astro-translations/backend-runtime/runtime/i18n.d.ts

@@ -0,0 +1,4 @@
+declare function getAbsoluteLocaleUrl(path?: string): string;
+declare function getRelativeLocaleUrl(path?: string): string;
+
+export { getAbsoluteLocaleUrl, getRelativeLocaleUrl };

package/build/dependencies/astro-translations/backend-runtime/runtime/i18n.js

@@ -0,0 +1,42 @@
+// src/runtime/i18n.ts
+import { i18n } from "@wix/essentials";
+import { applyLanguageToUrl } from "@wix/headless-localization-utils";
+import { listSupportedLanguages } from "@wix/multilingual-manager";
+var PLACEHOLDER_BASE = "http://localhost";
+var { base: configBase = "/", siteUrl } = __WIX_ASTRO_I18N__;
+function getAbsoluteLocaleUrl(path) {
+  const baseUrl = siteUrl ?? PLACEHOLDER_BASE;
+  const localizedUrl = buildLocalizedUrl(baseUrl, path);
+  if (siteUrl == null) {
+    const url = new URL(localizedUrl);
+    return url.pathname + url.search + url.hash;
+  }
+  return localizedUrl;
+}
+function getRelativeLocaleUrl(path) {
+  const localizedUrl = new URL(buildLocalizedUrl(PLACEHOLDER_BASE, path));
+  return localizedUrl.pathname + localizedUrl.search + localizedUrl.hash;
+}
+function buildLocalizedUrl(baseUrl, path) {
+  const basePath = configBase === "/" ? "" : configBase.replace(/\/$/, "");
+  const pathSegment = path?.startsWith("/") ? path : `/${path ?? ""}`;
+  const url = new URL(basePath + pathSegment || "/", baseUrl);
+  const languageConfig = getCurrentLanguageConfig();
+  return languageConfig ? applyLanguageToUrl(url.href, languageConfig) : url.href;
+}
+function getCurrentLanguageConfig() {
+  const currentLanguage = i18n.getLanguage();
+  const languages = listSupportedLanguages();
+  const language = languages.find((lang) => lang.id === currentLanguage);
+  if (language == null || language.primary) {
+    return;
+  }
+  return {
+    languageCode: language.id,
+    resolutionMethod: language.resolutionMethod
+  };
+}
+export {
+  getAbsoluteLocaleUrl,
+  getRelativeLocaleUrl
+};

package/build/dependencies/astro-translations/integration/index.js

@@ -0,0 +1,296 @@
+// src/index.ts
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/utils/loadTranslations.ts
+import { readdir } from "fs/promises";
+import { join as join2 } from "path";
+import { fileURLToPath } from "url";
+import { readJson } from "@wix/fs-utils";
+import { toNamespaceDictionary } from "@wix/headless-localization-utils";
+
+// src/constants.ts
+var TRANSLATIONS_METADATA_FILENAME = "metadata.json";
+var TRANSLATIONS_FILENAME = "translations.json";
+
+// src/utils/errorMessages.ts
+import { join } from "path";
+
+// ../../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/errorMessages.ts
+function createTranslationFilesError(translationsDir) {
+  return new Error(defaultOutdent`
+    Failed to load translation file(s).
+    💡 Tip: create a file '${join(translationsDir, "translations.json")}' in your project, then use the Wix CLI to push these keys.
+
+    Example translation file structure:
+    {
+      "hello": "Hello",
+      "goodbye": "Goodbye"
+    }
+
+    🔍 Need Help?
+    - Visit our docs: https://dev.wix.com/docs/go-headless
+  `);
+}
+
+// src/utils/loadTranslations.ts
+async function loadTranslationFile(filePath) {
+  return readJson(filePath).then(
+    (data) => toNamespaceDictionary(data)
+  );
+}
+async function loadAllTranslations(astroConfig) {
+  const srcDir = fileURLToPath(astroConfig.srcDir);
+  const rootDir = fileURLToPath(astroConfig.root);
+  const tempDir = join2(rootDir, ".wix");
+  const multilingualDir = join2(tempDir, "multilingual");
+  const primaryTranslationPath = join2(srcDir, TRANSLATIONS_FILENAME);
+  const pulledTranslationsDir = join2(multilingualDir, "translations");
+  let metadata;
+  let primaryTranslation;
+  try {
+    metadata = await loadMetadata(multilingualDir);
+    primaryTranslation = await loadPrimaryTranslation(
+      primaryTranslationPath,
+      metadata
+    );
+  } catch {
+    throw createTranslationFilesError(srcDir);
+  }
+  const wixTranslations = await loadTranslations(pulledTranslationsDir);
+  return { ...wixTranslations, ...primaryTranslation };
+}
+async function loadMetadata(translationsMetadataDir) {
+  const metadataPath = join2(
+    translationsMetadataDir,
+    TRANSLATIONS_METADATA_FILENAME
+  );
+  return await readJson(metadataPath);
+}
+async function loadPrimaryTranslation(primaryTranslationPath, metadata) {
+  const translationContent = await loadTranslationFile(primaryTranslationPath);
+  return {
+    [metadata.primaryLanguageCode]: translationContent
+  };
+}
+async function loadTranslations(translationsDir) {
+  const files = await readdir(translationsDir);
+  const jsonFiles = files.filter((file) => file.endsWith(".json"));
+  const translations = {};
+  for (const file of jsonFiles) {
+    const languageCode = file.replace(".json", "");
+    const filePath = join2(translationsDir, file);
+    translations[languageCode] = await loadTranslationFile(filePath);
+  }
+  return translations;
+}
+
+// src/vite/wix-astro-i18n-plugin.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+var VIRTUAL_MODULE_ID = "wix:astro:i18n";
+var RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
+var i18nRuntimePath = fileURLToPath2(
+  new URL(
+    "../dependencies/astro-translations/backend-runtime/runtime/i18n.js",
+    import.meta.url
+  )
+);
+var wixAstroI18nPlugin = () => {
+  return {
+    name: "vite-plugin-wix-astro-i18n",
+    enforce: "pre",
+    load(id) {
+      if (id !== RESOLVED_VIRTUAL_MODULE_ID) {
+        return;
+      }
+      return `export * from '${i18nRuntimePath}';`;
+    },
+    resolveId(id) {
+      return id === VIRTUAL_MODULE_ID ? RESOLVED_VIRTUAL_MODULE_ID : void 0;
+    }
+  };
+};
+
+// src/index.ts
+var i18nTypesPath = fileURLToPath3(
+  new URL(
+    "../dependencies/astro-translations/types/wix-astro-i18n.d.ts",
+    import.meta.url
+  )
+);
+var createIntegration = () => {
+  return {
+    name: "@wix/astro/static-translations",
+    hooks: {
+      "astro:config:setup": async ({
+        addMiddleware,
+        config: astroConfig,
+        updateConfig
+      }) => {
+        const translations = await loadAllTranslations(astroConfig);
+        updateConfig({
+          vite: {
+            define: {
+              __WIX_ASTRO_I18N__: JSON.stringify({
+                base: astroConfig.base,
+                siteUrl: astroConfig.site ?? null,
+                translations
+              })
+            },
+            plugins: [wixAstroI18nPlugin()]
+          }
+        });
+        addMiddleware({
+          entrypoint: new URL(
+            "../dependencies/astro-translations/backend-runtime/middleware/static-translations.js",
+            import.meta.url
+          ),
+          order: "pre"
+        });
+      },
+      "astro:config:done": async ({ injectTypes }) => {
+        injectTypes({
+          content: readFileSync(i18nTypesPath, "utf-8"),
+          filename: "wix-astro-i18n.d.ts"
+        });
+      }
+    }
+  };
+};
+var index_default = createIntegration;
+export {
+  index_default as default
+};

package/build/dependencies/astro-translations/types/wix-astro-i18n.d.ts

@@ -0,0 +1,18 @@
+declare module 'wix:astro:i18n' {
+  /**
+   * Returns a relative URL path with the current locale applied.
+   * Uses the language from the current request context.
+   *
+   * @param path - Optional path to localize (defaults to '/')
+   * @returns Localized relative URL (e.g., '/fr/getting-started')
+   */
+  export function getRelativeLocaleUrl(path?: string): string;
+
+  /**
+   * Returns an absolute URL with the current locale applied.
+   *
+   * @param path - Optional path to localize (defaults to '/')
+   * @returns Localized absolute URL (e.g., 'https://example.com/fr/getting-started')
+   */
+  export function getAbsoluteLocaleUrl(path?: string): string;
+}

package/build/dependencies/astro-viewer-services-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-viewer-services-extensions/types/index.d.ts

@@ -0,0 +1,27 @@
+import { WixIntegration, BaseExtension } from '@wix/astro-core';
+
+declare const createIntegration: () => WixIntegration;
+
+interface ViewerService extends BaseExtension {
+    type: 'ViewerService';
+    options: Options;
+}
+interface Options {
+    id: string;
+    description?: string;
+    docLink?: string;
+    editor?: {
+        [key: string]: unknown;
+        bundle: string;
+        dependencies?: string[];
+    };
+    packageName: string;
+    viewer: {
+        [key: string]: unknown;
+        bundle: string;
+        dependencies?: string[];
+    };
+}
+declare function viewerService(options: Options): ViewerService;
+
+export { createIntegration as default, viewerService };

package/build/integration/builders-experimental.js

@@ -3,7 +3,7 @@ const require = _createRequire(import.meta.url);
 import {
   contextProvider,
   functionLibrary
-} from "./chunk-XF55M5AE.js";
+} from "./chunk-MNQWQ2MC.js";
 import {
   init_esm_shims
 } from "./chunk-23MOLCVI.js";

package/build/integration/builders-trusted.js

@@ -3,7 +3,7 @@ const require = _createRequire(import.meta.url);
 import {
   trustedBackofficePage,
   trustedBackofficeWidget
-} from "./chunk-LQFJQHEX.js";
+} from "./chunk-KCOYXYJL.js";
 import {
   app,
   bookingsStaffSortingProvider,
@@ -20,7 +20,7 @@ import {
   siteComponentPanel,
   sitePlugin,
   webhook
-} from "./chunk-CTGNWVC3.js";
+} from "./chunk-E42TF2A2.js";
 import {
   init_esm_shims
 } from "./chunk-23MOLCVI.js";

package/build/integration/builders.d.ts

@@ -1,5 +1,5 @@
 import { b as bookingsStaffSortingProvider, c as customElement, e as ecomAdditionalFees, a as ecomDiscountTriggers, d as ecomGiftCards, f as ecomPaymentSettings, g as ecomShippingRates, h as ecomValidations, i as embeddedScript, w as webhook, s as siteComponent, j as siteComponentPanel, k as sitePlugin } from './index.d-BUVlSCHa.js';
-import { g as genericExtension } from './index.d-D4c48TR0.js';
+import { B as BaseExtension, g as genericExtension } from './index.d-D4c48TR0.js';
 export { a as app } from './index.d-D4c48TR0.js';
 
 interface BackofficeExtensionMenuPlugin {
@@ -55,15 +55,37 @@ declare function backofficeModal(options: Options$1): BackofficeModal;
 
 interface BackofficePage {
     type: 'BackofficePage';
-    options: Options;
+    options: Options$4;
 }
-interface Options {
+interface Options$4 {
     id: string;
     component: string;
     routePath: string;
     title: string;
 }
-declare function backofficePage(options: Options): BackofficePage;
+declare function backofficePage(options: Options$4): BackofficePage;
+
+interface ViewerService extends BaseExtension {
+    type: 'ViewerService';
+    options: Options;
+}
+interface Options {
+    id: string;
+    description?: string;
+    docLink?: string;
+    editor?: {
+        [key: string]: unknown;
+        bundle: string;
+        dependencies?: string[];
+    };
+    packageName: string;
+    viewer: {
+        [key: string]: unknown;
+        bundle: string;
+        dependencies?: string[];
+    };
+}
+declare function viewerService(options: Options): ViewerService;
 
 declare const extensions: {
     bookingsStaffSortingProvider: typeof bookingsStaffSortingProvider;
@@ -84,6 +106,7 @@ declare const extensions: {
     siteComponent: typeof siteComponent;
     siteComponentPanel: typeof siteComponentPanel;
     sitePlugin: typeof sitePlugin;
+    viewerService: typeof viewerService;
 };
 
 export { extensions };

package/build/integration/builders.js

@@ -2,10 +2,10 @@ import { createRequire as _createRequire } from 'node:module';
 const require = _createRequire(import.meta.url);
 import {
   extensions
-} from "./chunk-S5CQHYTB.js";
+} from "./chunk-CBVCNKLN.js";
 import {
   app
-} from "./chunk-CTGNWVC3.js";
+} from "./chunk-E42TF2A2.js";
 import "./chunk-23MOLCVI.js";
 export {
   app,