@bagelink/blox 1.13.5 → 1.14.0

package/dist/core-CPXNfJ-Z.js

@@ -0,0 +1,460 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { BLOX_WEBSITE_ID_WINDOW_KEY, BLOX_STATE_WINDOW_KEY } from "./ssg/client.mjs";
+import { computed, ref, defineComponent, inject, h, provide, watch, resolveComponent, createElementBlock, openBlock, createElementVNode, createVNode, toDisplayString, unref, withCtx, createTextVNode, Fragment, createCommentVNode, createBlock, normalizeProps, guardReactiveProps, renderSlot } from "vue";
+import { useRoute, useRouter, RouterLink } from "vue-router";
+import { getI18n } from "@bagelink/vue";
+const BASE = "/api";
+let _websiteName = "";
+let _store = "";
+let _websiteId = null;
+function configureApi(websiteName, store) {
+  _websiteName = websiteName;
+  _store = store;
+  _websiteId = null;
+}
+async function request(path, { locale: locale2, params, ...opts } = {}) {
+  const url = new URL(`${BASE}${path}`, window.location.origin);
+  if (locale2) url.searchParams.set("locale", locale2);
+  if (params) {
+    for (const [k, v] of Object.entries(params)) url.searchParams.set(k, String(v));
+  }
+  const res = await fetch(url.toString(), opts);
+  if (!res.ok) throw new Error(`API ${res.status}: ${path}`);
+  if (res.status === 204) return null;
+  return res.json();
+}
+async function getWebsiteId() {
+  if (_websiteId) return _websiteId;
+  if (typeof window !== "undefined") {
+    const embedded = window[BLOX_WEBSITE_ID_WINDOW_KEY];
+    if (typeof embedded === "string" && embedded !== "") {
+      _websiteId = embedded;
+      return _websiteId;
+    }
+  }
+  const websites = await request("/cms/websites");
+  const website = websites.find((w) => w.name === _websiteName);
+  if (!website) throw new Error(`Website "${_websiteName}" not found. Run: npm run seed`);
+  _websiteId = website.id;
+  return _websiteId;
+}
+async function resolvePath(path, locale2) {
+  const websiteId = await getWebsiteId();
+  return request(`/cms/websites/${websiteId}/resolve-path`, {
+    locale: locale2,
+    params: { path }
+  });
+}
+async function listItems(collection, { locale: locale2, q, offset = 0, limit = 100 } = {}) {
+  return request(`/datastore/${_store}/collections/${collection}`, {
+    locale: locale2,
+    params: { ...q ? { q } : {}, offset, limit }
+  });
+}
+const locale = ref(localStorage.getItem("blox:locale") || "en");
+const currentAlternates = ref({});
+function useLocale() {
+  const dir = computed(() => locale.value === "he" || locale.value === "ar" ? "rtl" : "ltr");
+  function setLocale(l) {
+    locale.value = l;
+    localStorage.setItem("blox:locale", l);
+    document.documentElement.lang = l;
+    document.documentElement.dir = dir.value;
+    try {
+      const i18n = getI18n();
+      if (i18n == null ? void 0 : i18n.global) i18n.global.locale.value = l;
+    } catch {
+    }
+  }
+  function setAlternates(alternates) {
+    currentAlternates.value = alternates;
+  }
+  return { locale, dir, setLocale, currentAlternates, setAlternates };
+}
+const BLOX_REGISTRY_KEY = Symbol("blox:registry");
+const BLOX_CONFIG_KEY = Symbol("blox:config");
+const BLOX_LOCALE_STRATEGY_KEY = Symbol("blox:locale-strategy");
+const PageRenderer = defineComponent({
+  name: "PageRenderer",
+  props: {
+    blocks: {
+      type: Array,
+      default: () => []
+    }
+  },
+  setup(props) {
+    const registry = inject(BLOX_REGISTRY_KEY, {});
+    return () => h(
+      "div",
+      props.blocks.flatMap((block, i) => {
+        const definition = registry[block.type];
+        if (!definition) return [];
+        const props2 = { ...definition.schema.defaults, ...block.props };
+        return [h(definition.component, { key: i, ...props2 })];
+      })
+    );
+  }
+});
+const _hoisted_1 = {
+  key: 0,
+  class: "blox-loading"
+};
+const _hoisted_2 = {
+  key: 1,
+  class: "blox-not-found"
+};
+const _hoisted_3 = {
+  key: 2,
+  class: "blox-error color-red"
+};
+const _hoisted_4 = {
+  key: 0,
+  class: "blox-nav-progress"
+};
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  __name: "CmsPageView",
+  setup(__props) {
+    const route = useRoute();
+    const router = useRouter();
+    const { locale: locale2, setLocale, setAlternates } = useLocale();
+    const strategy = inject(BLOX_LOCALE_STRATEGY_KEY, null);
+    const blocks = ref([]);
+    const contexts = ref({});
+    provide("contexts", contexts);
+    const notFound = ref(false);
+    const error = ref(null);
+    const initialLoading = ref(true);
+    const navigating = ref(false);
+    function tryHydrateFromState(path) {
+      var _a, _b;
+      const win = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : void 0;
+      if (!win) return false;
+      const state = win[BLOX_STATE_WINDOW_KEY];
+      if (!state || typeof state !== "object") return false;
+      const entry = state[path];
+      if (!entry) return false;
+      blocks.value = ((_b = (_a = entry.page) == null ? void 0 : _a.content) == null ? void 0 : _b.blocks) ?? [];
+      contexts.value = entry.contexts ?? {};
+      setAlternates(entry.alternates ?? {});
+      return true;
+    }
+    function updateDocumentTitle(resolved) {
+      if (typeof document === "undefined") return;
+      const { page } = resolved;
+      const ctx = resolved.contexts ? Object.values(resolved.contexts).find((c) => c != null) : null;
+      const ctxTitle = ctx && typeof ctx.title === "string" ? ctx.title : null;
+      const title = page.meta_title || ctxTitle || page.title;
+      if (title) document.title = title;
+    }
+    const initialSlug = (() => {
+      var _a;
+      if (strategy) {
+        const hostname = typeof window !== "undefined" ? ((_a = window.location) == null ? void 0 : _a.hostname) ?? "" : "";
+        return strategy.detect(hostname, route.path).slug;
+      }
+      return route.path || "/";
+    })();
+    const ssrHydrated = tryHydrateFromState(initialSlug);
+    if (ssrHydrated) initialLoading.value = false;
+    async function load() {
+      var _a;
+      notFound.value = false;
+      error.value = null;
+      const { locale: urlLocale, slug } = strategy ? strategy.detect(typeof window !== "undefined" ? window.location.hostname : "", route.path) : { locale: locale2.value, slug: route.path || "/" };
+      if (urlLocale !== locale2.value) setLocale(urlLocale);
+      if (tryHydrateFromState(slug)) {
+        initialLoading.value = false;
+        return;
+      }
+      navigating.value = true;
+      try {
+        const resolved = await resolvePath(slug, urlLocale);
+        blocks.value = ((_a = resolved.page.content) == null ? void 0 : _a.blocks) ?? [];
+        contexts.value = resolved.contexts ?? {};
+        setAlternates(resolved.alternates ?? {});
+        updateDocumentTitle(resolved);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (msg.includes("404")) {
+          const home = strategy ? strategy.toPath("/") : "/";
+          router.replace(home);
+        } else {
+          error.value = msg;
+        }
+      } finally {
+        initialLoading.value = false;
+        navigating.value = false;
+      }
+    }
+    if (!ssrHydrated) {
+      load();
+    }
+    watch(() => route.path, load);
+    return (_ctx, _cache) => {
+      const _component_RouterLink = resolveComponent("RouterLink");
+      return openBlock(), createElementBlock("div", null, [
+        initialLoading.value && blocks.value.length === 0 ? (openBlock(), createElementBlock("div", _hoisted_1, " Loading… ")) : notFound.value ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          _cache[0] || (_cache[0] = createElementVNode("h2", null, "404", -1)),
+          createElementVNode("p", null, toDisplayString(unref(locale2) === "he" ? "הדף לא נמצא" : "Page not found"), 1),
+          createVNode(_component_RouterLink, { to: "/" }, {
+            default: withCtx(() => [
+              createTextVNode(toDisplayString(unref(locale2) === "he" ? "חזרה הביתה" : "Go home"), 1)
+            ]),
+            _: 1
+          })
+        ])) : error.value ? (openBlock(), createElementBlock("div", _hoisted_3, toDisplayString(error.value), 1)) : (openBlock(), createElementBlock(Fragment, { key: 3 }, [
+          navigating.value ? (openBlock(), createElementBlock("div", _hoisted_4)) : createCommentVNode("", true),
+          createVNode(unref(PageRenderer), { blocks: blocks.value }, null, 8, ["blocks"])
+        ], 64))
+      ]);
+    };
+  }
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "LocaleRouterLink",
+  props: {
+    to: {},
+    replace: { type: Boolean },
+    activeClass: {},
+    exactActiveClass: {},
+    ariaCurrentValue: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const strategy = inject(BLOX_LOCALE_STRATEGY_KEY, null);
+    const localizedTo = computed(() => {
+      if (!strategy || typeof props.to !== "string") return props.to;
+      return strategy.toPath(props.to);
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(RouterLink), normalizeProps(guardReactiveProps({ ...props, to: localizedTo.value })), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+function createPathStrategy(options) {
+  const { defaultLocale, supportedLocales } = options;
+  let _currentLocale = defaultLocale;
+  return {
+    get locales() {
+      return supportedLocales;
+    },
+    get currentLocale() {
+      return _currentLocale;
+    },
+    detect(_hostname, path) {
+      const segments = path.replace(/^\//, "").split("/");
+      const first = segments[0];
+      if (supportedLocales.includes(first)) {
+        _currentLocale = first;
+        return {
+          locale: first,
+          slug: `/${segments.slice(1).join("/")}` || "/"
+        };
+      }
+      _currentLocale = defaultLocale;
+      return { locale: defaultLocale, slug: path || "/" };
+    },
+    toPath(slug) {
+      if (_currentLocale === defaultLocale) return slug || "/";
+      const s = slug || "/";
+      return s === "/" ? `/${_currentLocale}` : `/${_currentLocale}${s}`;
+    },
+    switchTo(locale2, slug, router) {
+      const s = slug || "/";
+      const target = locale2 === defaultLocale ? s : s === "/" ? `/${locale2}` : `/${locale2}${s}`;
+      router.push(target);
+    }
+  };
+}
+function createDomainStrategy(options) {
+  const { localeDomains } = options;
+  const locales = Object.keys(localeDomains);
+  const _currentLocale = locales.find((l) => localeDomains[l] === window.location.hostname) ?? locales[0] ?? "en";
+  return {
+    get locales() {
+      return locales;
+    },
+    get currentLocale() {
+      return _currentLocale;
+    },
+    detect(_hostname, path) {
+      return { locale: _currentLocale, slug: path || "/" };
+    },
+    toPath(slug) {
+      return slug || "/";
+    },
+    switchTo(locale2, slug, _router) {
+      const domain = localeDomains[locale2];
+      if (!domain) return;
+      if (locale2 === _currentLocale) {
+        _router.push(slug || "/");
+        return;
+      }
+      const { protocol } = window.location;
+      const s = slug || "/";
+      window.location.href = `${protocol}//${domain}${s}`;
+    }
+  };
+}
+function createLocaleStrategy(options) {
+  if (options.localeStrategy === "domain" && options.localeDomains) {
+    return createDomainStrategy({ localeDomains: options.localeDomains });
+  }
+  return createPathStrategy({
+    defaultLocale: options.defaultLocale ?? "en",
+    supportedLocales: options.supportedLocales ?? []
+  });
+}
+function applyDefaultsToFields(schema, defaults) {
+  var _a;
+  if (!schema || !defaults) return;
+  for (const [key, value] of Object.entries(defaults)) {
+    const field = (_a = schema._fields) == null ? void 0 : _a[key];
+    if (field && field._config.default === void 0) {
+      field._config.default = value;
+    }
+  }
+}
+class BloxInstance {
+  constructor(options) {
+    __publicField(this, "_registry", {});
+    __publicField(this, "_routeRegistered", false);
+    __publicField(this, "_config");
+    __publicField(this, "_strategy");
+    this._config = {
+      defaultLocale: (options == null ? void 0 : options.defaultLocale) ?? "en",
+      supportedLocales: (options == null ? void 0 : options.supportedLocales) ?? []
+    };
+    this._strategy = createLocaleStrategy(options ?? {});
+  }
+  registerModules(modules) {
+    const list = Array.isArray(modules) ? modules : Object.values(modules);
+    for (const mod of list) {
+      if (!(mod == null ? void 0 : mod.default)) continue;
+      for (const [key, value] of Object.entries(mod)) {
+        if (key === "default") continue;
+        if (value && typeof value === "object" && "label" in value) {
+          const meta = value;
+          applyDefaultsToFields(meta.schema, meta.defaults);
+          this._registry[meta.name ?? key] = {
+            component: mod.default,
+            schema: {
+              label: meta.label,
+              description: meta.description,
+              icon: meta.icon,
+              fields: meta.schema,
+              defaults: meta.defaults,
+              dataSource: meta.dataSource
+            }
+          };
+          break;
+        }
+      }
+    }
+    return this;
+  }
+  registerComponents(components) {
+    for (const [key, value] of Object.entries(components)) {
+      if (!value || typeof value !== "object" && typeof value !== "function") continue;
+      if (isBlockDefinition(value)) {
+        this._registry[key] = value;
+      } else if (value.__blox) {
+        const meta = value.__blox;
+        applyDefaultsToFields(meta.schema, meta.defaults);
+        this._registry[meta.name ?? key] = {
+          component: value,
+          schema: {
+            label: meta.label,
+            description: meta.description,
+            icon: meta.icon,
+            fields: meta.schema,
+            defaults: meta.defaults,
+            dataSource: meta.dataSource
+          }
+        };
+      }
+    }
+    return this;
+  }
+  registerRoutes(router) {
+    if (this._routeRegistered) return this;
+    if (this._config.supportedLocales.length > 0) {
+      const { defaultLocale } = this._config;
+      router.beforeEach((to) => {
+        const segments = to.path.replace(/^\//, "").split("/");
+        if (segments[0] === defaultLocale) {
+          const rest = segments.slice(1).join("/");
+          return { path: `/${rest}`, replace: true };
+        }
+      });
+    }
+    router.addRoute({
+      path: "/_blox_preview",
+      component: () => import("./PreviewApp-BrthGx2F.js"),
+      beforeEnter: () => window.parent !== window ? true : "/"
+    });
+    router.addRoute({ path: "/:pathMatch(.*)*", component: _sfc_main$1 });
+    this._routeRegistered = true;
+    return this;
+  }
+  install(app, options) {
+    if (options) {
+      this._config = {
+        defaultLocale: options.defaultLocale ?? this._config.defaultLocale,
+        supportedLocales: options.supportedLocales ?? this._config.supportedLocales
+      };
+      this._strategy = createLocaleStrategy({
+        ...options,
+        defaultLocale: this._config.defaultLocale,
+        supportedLocales: this._config.supportedLocales
+      });
+    }
+    if (options == null ? void 0 : options.modules) this.registerModules(options.modules);
+    if (options == null ? void 0 : options.components) this.registerComponents(options.components);
+    if (options == null ? void 0 : options.router) this.registerRoutes(options.router);
+    if ((options == null ? void 0 : options.websiteName) || (options == null ? void 0 : options.store)) {
+      configureApi(options.websiteName ?? "", options.store ?? "");
+    }
+    if (options == null ? void 0 : options.defaultLocale) {
+      const { setLocale } = useLocale();
+      if (!localStorage.getItem("blox:locale")) setLocale(options.defaultLocale);
+    }
+    app.provide(BLOX_REGISTRY_KEY, this._registry);
+    app.provide(BLOX_CONFIG_KEY, this._config);
+    app.provide(BLOX_LOCALE_STRATEGY_KEY, this._strategy);
+    app.component("RouterLink", _sfc_main);
+  }
+}
+function isBlockDefinition(value) {
+  return typeof value === "object" && "component" in value && "schema" in value;
+}
+function createBlox(options) {
+  const instance = new BloxInstance(options);
+  if ((options == null ? void 0 : options.websiteName) || (options == null ? void 0 : options.store)) {
+    configureApi(options.websiteName ?? "", options.store ?? "");
+  }
+  if (options == null ? void 0 : options.modules) instance.registerModules(options.modules);
+  if (options == null ? void 0 : options.components) instance.registerComponents(options.components);
+  if (options == null ? void 0 : options.router) instance.registerRoutes(options.router);
+  return instance;
+}
+export {
+  BLOX_LOCALE_STRATEGY_KEY as B,
+  PageRenderer as P,
+  _sfc_main$1 as _,
+  configureApi as a,
+  BloxInstance as b,
+  createBlox as c,
+  BLOX_CONFIG_KEY as d,
+  BLOX_REGISTRY_KEY as e,
+  listItems as l,
+  resolvePath as r,
+  useLocale as u
+};