@blokkli/editor 2.0.0-alpha.53 → 2.0.0-alpha.55

package/dist/runtime/editor/providers/texts.js

@@ -1,53 +1,50 @@
-import { computed, ref } from "vue";
+import { shallowRef } from "vue";
 import {
-  translations
+  translationLoaders
 } from "#blokkli-build/translations";
 import {
   defaultLanguage,
   forceDefaultLanguage
 } from "#blokkli-build/editor-config";
-import { LANGUAGES } from "../../../global/constants";
+import { TRANSLATION_LANGUAGES } from "../../../global/constants";
 function isInterfaceLanguage(value) {
-  return LANGUAGES.includes(value);
+  return TRANSLATION_LANGUAGES.includes(value);
 }
 const DEBUG_SWISS_GERMAN = false;
-export default function(context) {
-  const allTranslations = ref(translations);
+function resolveEffectiveLanguage(requested) {
+  const today = /* @__PURE__ */ new Date();
+  const isAprilFirst = today.getMonth() === 3 && today.getDate() === 1;
+  if (isAprilFirst && requested === "de" || DEBUG_SWISS_GERMAN && import.meta.dev && requested === "de") {
+    return "gsw_CH";
+  }
+  if (forceDefaultLanguage) {
+    return defaultLanguage;
+  }
+  if (isInterfaceLanguage(requested)) {
+    return requested;
+  }
+  return defaultLanguage;
+}
+export default async function(requestedLanguage) {
+  const language = resolveEffectiveLanguage(requestedLanguage);
+  const currentTranslations = shallowRef({});
+  async function loadTranslations(loaders, langcode) {
+    const loader = loaders[langcode];
+    if (loader) {
+      currentTranslations.value = await loader();
+    } else {
+      currentTranslations.value = {};
+    }
+  }
   if (import.meta.hot) {
-    import.meta.hot.accept("#blokkli-build/translations", (mod) => {
-      if (mod?.translations) {
-        allTranslations.value = mod.translations;
+    import.meta.hot.accept("#blokkli-build/translations", async (mod) => {
+      if (mod?.translationLoaders) {
+        loadTranslations(mod.translationLoaders, language);
       }
     });
   }
-  const language = computed(() => {
-    if (forceDefaultLanguage) {
-      return defaultLanguage;
-    }
-    if (context?.value.language && isInterfaceLanguage(context.value.language)) {
-      return context.value.language;
-    }
-    return defaultLanguage;
-  });
-  const currentTranslations = computed(() => {
-    const today = /* @__PURE__ */ new Date();
-    const isAprilFirst = today.getMonth() === 3 && today.getDate() === 1;
-    if (isAprilFirst && language.value === "de" || DEBUG_SWISS_GERMAN && import.meta.dev) {
-      return allTranslations.value.gsw_CH || allTranslations.value[language.value] || {};
-    }
-    return allTranslations.value[language.value] || {};
-  });
+  await loadTranslations(translationLoaders, language);
   return (key, defaultValue) => {
-    const existingForCurrent = currentTranslations.value[key];
-    if (existingForCurrent) {
-      return existingForCurrent;
-    }
-    if (language.value === "gsw_CH") {
-      const fallback = translations.de[key];
-      if (fallback) {
-        return fallback;
-      }
-    }
-    return defaultValue || key;
+    return currentTranslations.value[key] || defaultValue || key;
   };
 }

package/dist/runtime/editor/providers/workspaces.d.ts

@@ -0,0 +1,93 @@
+import { type Ref, type ComputedRef } from '#imports';
+import type { AdapterContext, FullBlokkliAdapter } from '#blokkli/editor/adapter';
+import type { StateProvider } from './state.js';
+export type HostEntitySearchResultLabelMap = {
+    label: string;
+    bundles: Record<string, string>;
+};
+export type HostEntitySearchResultItem = {
+    /**
+     * The ID of the host entity.
+     */
+    id: string;
+    /**
+     * The UUID of the host entity.
+     */
+    uuid: string;
+    /**
+     * The entity type of the host entity.
+     */
+    entityType: string;
+    /**
+     * The entity bundle of the host entity.
+     */
+    bundle: string;
+    /**
+     * The label of the host entity.
+     */
+    label: string;
+    /**
+     * The url to start editing.
+     */
+    url: string;
+    /**
+     * If an edit state exists: The time when the edit state was last changed.
+     */
+    lastChanged: string | null;
+    /**
+     * If an edit state exists: The ID of the owner of the edit state.
+     */
+    uid: string | null;
+    /**
+     * Optional additional context used for searching (e.g. SKU, internal ID).
+     *
+     * Not displayed in the UI, but included in the fzf search.
+     */
+    context?: string;
+};
+export type HostEntitySearchResult = {
+    items: HostEntitySearchResultItem[];
+    /**
+     * A map with keys that are entity types.
+     */
+    labelMap: HostEntitySearchResultLabelMap;
+};
+export type WorkspacesProvider = {
+    /**
+     * Whether the host entities have been fetched.
+     */
+    isLoaded: Readonly<Ref<boolean>>;
+    /**
+     * Whether the host entities are currently being fetched.
+     */
+    isLoading: Readonly<Ref<boolean>>;
+    /**
+     * Loaded items minus the current entity, in workspace default sort order:
+     * entries with edit states first → current user as owner → most-recent →
+     * alphabetic by label.
+     */
+    defaultSorted: ComputedRef<HostEntitySearchResultItem[]>;
+    /**
+     * Load the host entities. Idempotent — concurrent calls share the same
+     * in-flight promise, and resolved data is reused on subsequent calls.
+     */
+    ensureLoaded: () => Promise<void>;
+    /**
+     * Run a fuzzy search over loaded items. Resolves to fzf-ordered results
+     * (excluding the current entity). An empty/whitespace query resolves to [].
+     */
+    search: (query: string) => Promise<HostEntitySearchResultItem[]>;
+    /**
+     * Translated label for a bundle key, falling back to the key itself.
+     */
+    getBundleLabel: (bundle: string) => string;
+};
+declare module '#blokkli/editor/adapter' {
+    interface BlokkliAdapter<T> {
+        /**
+         * Search for host entities.
+         */
+        getHostEntities?: () => Promise<HostEntitySearchResult>;
+    }
+}
+export default function workspacesProvider(adapter: FullBlokkliAdapter<any>, context: ComputedRef<AdapterContext>, state: StateProvider): WorkspacesProvider;

package/dist/runtime/editor/providers/workspaces.js

@@ -0,0 +1,76 @@
+import { ref, computed } from "#imports";
+import { loadFzf } from "#blokkli/editor/libraries/fzf";
+export default function workspacesProvider(adapter, context, state) {
+  const items = ref([]);
+  const labelMap = ref(null);
+  const isLoaded = ref(false);
+  const isLoading = ref(false);
+  let loadPromise = null;
+  let fzf = null;
+  function ensureLoaded() {
+    if (isLoaded.value) {
+      return Promise.resolve();
+    }
+    if (loadPromise) {
+      return loadPromise;
+    }
+    isLoading.value = true;
+    loadPromise = adapter.getHostEntities().then((result) => {
+      items.value = result.items;
+      labelMap.value = result.labelMap;
+      isLoaded.value = true;
+    }).finally(() => {
+      isLoading.value = false;
+    });
+    return loadPromise;
+  }
+  const ownerId = computed(() => state.owner.value?.id);
+  const currentEntityUuid = computed(() => context.value.entityUuid);
+  const defaultSorted = computed(() => {
+    return items.value.filter((v) => v.uuid !== currentEntityUuid.value).sort((a, b) => {
+      const aHasState = a.lastChanged !== null ? 0 : 1;
+      const bHasState = b.lastChanged !== null ? 0 : 1;
+      if (aHasState !== bHasState) return aHasState - bHasState;
+      const aIsOwner = a.uid && a.uid === ownerId.value ? 0 : 1;
+      const bIsOwner = b.uid && b.uid === ownerId.value ? 0 : 1;
+      if (aIsOwner !== bIsOwner) return aIsOwner - bIsOwner;
+      if (a.lastChanged && b.lastChanged) {
+        return new Date(b.lastChanged).getTime() - new Date(a.lastChanged).getTime();
+      }
+      if (a.lastChanged) return -1;
+      if (b.lastChanged) return 1;
+      return a.label.localeCompare(b.label);
+    });
+  });
+  async function getFzf() {
+    if (!fzf) {
+      const { AsyncFzf, asyncExtendedMatch } = await loadFzf();
+      fzf = new AsyncFzf(items.value, {
+        selector: (item) => item.context ? item.label + " " + item.context : item.label,
+        match: asyncExtendedMatch
+      });
+    }
+    return fzf;
+  }
+  async function search(query) {
+    const trimmed = query.trim();
+    if (!trimmed) {
+      return [];
+    }
+    await ensureLoaded();
+    const instance = await getFzf();
+    const results = await instance.find(trimmed);
+    return results.map((r) => r.item).filter((v) => v.uuid !== currentEntityUuid.value);
+  }
+  function getBundleLabel(bundle) {
+    return labelMap.value?.bundles[bundle] ?? bundle;
+  }
+  return {
+    isLoaded,
+    isLoading,
+    defaultSorted,
+    ensureLoaded,
+    search,
+    getBundleLabel
+  };
+}