@blokkli/editor 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/runtime/helpers/stateProvider.d.ts

@@ -1,6 +1,6 @@
 import { type Ref, type ComputedRef } from 'vue';
 import type { BlokkliAdapter, AdapterContext } from '../adapter/index.js';
-import type { MutatedField, EditEntity, MutatedOptions, TranslationState, MutationItem, Validation, MutateWithLoadingStateFunction, EditMode, FieldListItem } from '#blokkli/types';
+import type { MutatedField, EditEntity, MutatedOptions, TranslationState, MappedState, MutationItem, Validation, MutateWithLoadingStateFunction, EditMode, FieldListItem, PublishOptions, EditPermission } from '#blokkli/types';
 import type { TextProvider } from './textProvider.js';
 export type BlokkliOwner = {
     name: string | undefined;
@@ -19,6 +19,7 @@ export type StateProvider = {
     entity: Readonly<Ref<EditEntity>>;
     mutatedOptions: MutatedOptions;
     translation: Readonly<Ref<TranslationState>>;
+    publishOptions: Readonly<Ref<PublishOptions>>;
     mutations: Readonly<Ref<MutationItem[]>>;
     currentMutationIndex: Readonly<Ref<number>>;
     violations: Readonly<Ref<Validation[]>>;
@@ -26,12 +27,21 @@ export type StateProvider = {
     editMode: Readonly<Ref<EditMode>>;
     mutatedEntity: Readonly<Ref<any>>;
     canEdit: ComputedRef<boolean>;
+    permissions: ComputedRef<EditPermission[]>;
     stateAvailable: ComputedRef<boolean>;
     isLoading: Readonly<Ref<boolean>>;
+    fromLibraryUuids: Readonly<Ref<Readonly<string[]>>>;
     getFieldBlockCount: (key: string) => number;
     getBlockBundleCount: (bundle: string) => number;
     getFieldListItem: (uuid: string) => FieldListItem | undefined;
     getFieldListForBlock: (uuid: string) => MutatedField | undefined;
     getMutatedField: (uuid: string, fieldName: string) => MutatedField | undefined;
+    getAllUuids: (bundle?: string) => string[];
+    getNestingLevel: (uuid: string) => number;
+    isChildOf: (childUuid: string, parentUuid: string) => boolean;
+    getMappedState: () => MappedState;
+    setOverrideState: (state: MappedState) => void;
+    clearOverrideState: () => void;
+    getFieldKeyForUuid: (uuid: string) => string | null;
 };
-export default function (adapter: BlokkliAdapter<any>, context: ComputedRef<AdapterContext>, $t: TextProvider): Promise<StateProvider>;
+export default function (adapter: BlokkliAdapter<any>, context: ComputedRef<AdapterContext>, $t: TextProvider, providerKey: string, permissions: EditPermission[]): Promise<StateProvider>;

package/dist/runtime/helpers/stateProvider.js

@@ -5,13 +5,29 @@ import {
   readonly,
   provide
 } from "vue";
-import { refreshNuxtData } from "nuxt/app";
+import { refreshNuxtData, useState } from "nuxt/app";
 import { INJECT_MUTATED_FIELDS_MAP } from "./symbols.js";
 import onBlokkliEvent from "./composables/onBlokkliEvent.js";
 import { falsy, getFieldKey } from "#blokkli/helpers";
 import { eventBus, emitMessage } from "#blokkli/helpers/eventBus";
 import { nextTick } from "#imports";
-export default async function(adapter, context, $t) {
+import { addElementClasses } from "./addElementClasses.js";
+import { BUNDLE_FROM_LIBRARY } from "#blokkli/constants";
+const HOST_OPTION_KEY = "HOST";
+function mapPublishOptions(context) {
+  return {
+    canPublish: !!context?.publishOptions?.canPublish,
+    isRevisionable: !!context?.publishOptions?.isRevisionable,
+    hasRevisionLogMessage: !!context?.publishOptions?.hasRevisionLogMessage,
+    canSchedule: !!context?.publishOptions?.canSchedule,
+    lastChanged: context?.publishOptions?.lastChanged ?? null,
+    publishOn: context?.publishOptions?.publishOn ?? null,
+    revisionLogMessage: context?.publishOptions?.revisionLogMessage ?? null
+  };
+}
+export default async function(adapter, context, $t, providerKey, permissions) {
+  let _mappedState = null;
+  const overrideHostOptions = useState("options:" + providerKey);
   const stateLoaded = ref(false);
   const stateLoadError = ref(false);
   const owner = ref(null);
@@ -23,6 +39,15 @@ export default async function(adapter, context, $t) {
   const mutations = ref([]);
   const violations = ref([]);
   const mutatedEntity = ref(null);
+  const publishOptions = ref({
+    canPublish: false,
+    isRevisionable: false,
+    hasRevisionLogMessage: false,
+    lastChanged: null,
+    canSchedule: false,
+    publishOn: null,
+    revisionLogMessage: null
+  });
   const currentMutationIndex = ref(-1);
   const isLoading = ref(false);
   const entity = ref({
@@ -32,9 +57,12 @@ export default async function(adapter, context, $t) {
   });
   let fieldBlockCount = {};
   const blockBundleCount = ref({});
-  const fieldListItemMap = {};
+  const fieldListItemMap = ref({});
+  let bundleToUuids = {};
+  const fromLibraryUuids = ref([]);
+  const nestingLevelMap = /* @__PURE__ */ new Map();
   function getFieldListItem(uuid) {
-    const fieldKey = fieldListItemMap[uuid];
+    const fieldKey = fieldListItemMap.value[uuid];
     if (!fieldKey) {
       return;
     }
@@ -44,8 +72,11 @@ export default async function(adapter, context, $t) {
     }
     return field.list.find((v) => v.uuid === uuid);
   }
+  function getFieldKeyForUuid(uuid) {
+    return fieldListItemMap.value[uuid] ?? null;
+  }
   function getFieldListForBlock(uuid) {
-    const fieldKey = fieldListItemMap[uuid];
+    const fieldKey = fieldListItemMap.value[uuid];
     if (!fieldKey) {
       return;
     }
@@ -58,17 +89,35 @@ export default async function(adapter, context, $t) {
     availableLanguages: [],
     translations: []
   });
-  function setContext(context2) {
+  function updatePublishOptions(newPublishOptions) {
+    publishOptions.value.canPublish = newPublishOptions.canPublish;
+    publishOptions.value.isRevisionable = newPublishOptions.isRevisionable;
+    publishOptions.value.hasRevisionLogMessage = newPublishOptions.hasRevisionLogMessage;
+    publishOptions.value.lastChanged = newPublishOptions.lastChanged;
+    publishOptions.value.canSchedule = newPublishOptions.canSchedule;
+    publishOptions.value.publishOn = newPublishOptions.publishOn;
+    publishOptions.value.revisionLogMessage = newPublishOptions.revisionLogMessage;
+  }
+  function setContext(context2, override) {
+    if (!override) {
+      _mappedState = context2 ?? null;
+    }
     const options = context2?.mutatedState?.mutatedOptions || {};
     const optionKeys = Object.keys(options);
     for (let i = 0; i < optionKeys.length; i++) {
       const key = optionKeys[i];
       const newOptions = options[key];
-      const existing = mutatedOptions[key];
-      if (!existing || JSON.stringify(existing) !== JSON.stringify(newOptions)) {
+      const existing2 = mutatedOptions[key];
+      if (!existing2 || JSON.stringify(existing2) !== JSON.stringify(newOptions)) {
         mutatedOptions[key] = newOptions;
       }
     }
+    const hostOptions = context2?.mutatedState?.mutatedHostOptions ?? {};
+    const existing = mutatedOptions[HOST_OPTION_KEY];
+    if (!existing || JSON.stringify(existing) !== JSON.stringify(hostOptions)) {
+      mutatedOptions[HOST_OPTION_KEY] = hostOptions ?? "";
+      overrideHostOptions.value = hostOptions;
+    }
     mutations.value = context2?.mutations || [];
     violations.value = context2?.mutatedState?.violations || [];
     const currentIndex = context2?.currentIndex;
@@ -80,6 +129,7 @@ export default async function(adapter, context, $t) {
     entity.value.label = context2?.entity?.label;
     entity.value.status = context2?.entity?.status;
     entity.value.bundleLabel = context2?.entity?.bundleLabel || "";
+    updatePublishOptions(mapPublishOptions(context2));
     translation.value.isTranslatable = !!context2?.translationState?.isTranslatable;
     translation.value.translations = context2?.translationState?.translations?.filter(falsy) || [];
     translation.value.sourceLanguage = context2?.translationState?.sourceLanguage || "";
@@ -96,13 +146,17 @@ export default async function(adapter, context, $t) {
     mutatedEntity.value = context2?.mutatedEntity;
     const visitedFieldKeys = [];
     const newBlockBundleCount = {};
+    fieldListItemMap.value = {};
+    nestingLevelMap.clear();
     fieldBlockCount = {};
+    bundleToUuids = {};
+    const fromLibrary = [];
     for (let i = 0; i < newMutatedFields.length; i++) {
       const field = newMutatedFields[i];
       const key = getFieldKey(field.entityUuid, field.name);
       visitedFieldKeys.push(key);
-      const existing = mutatedFieldsMap[key];
-      if (!existing || existing.list.length !== field.list.length || JSON.stringify(existing.list) !== JSON.stringify(field.list)) {
+      const existing2 = mutatedFieldsMap[key];
+      if (!existing2 || existing2.list.length !== field.list.length || JSON.stringify(existing2.list) !== JSON.stringify(field.list)) {
         mutatedFieldsMap[key] = field;
       }
       for (let j = 0; j < field.list.length; j++) {
@@ -111,7 +165,21 @@ export default async function(adapter, context, $t) {
           newBlockBundleCount[item.bundle] = 0;
         }
         newBlockBundleCount[item.bundle]++;
-        fieldListItemMap[item.uuid] = key;
+        fieldListItemMap.value[item.uuid] = key;
+        if (!bundleToUuids[item.bundle]) {
+          bundleToUuids[item.bundle] = [];
+        }
+        bundleToUuids[item.bundle].push(item.uuid);
+        if (item.bundle === BUNDLE_FROM_LIBRARY) {
+          fromLibrary.push(item.uuid);
+        }
+      }
+    }
+    for (let i = 0; i < newMutatedFields.length; i++) {
+      const field = newMutatedFields[i];
+      for (let j = 0; j < field.list.length; j++) {
+        const item = field.list[j];
+        calculateNestingLevel(item.uuid);
       }
     }
     blockBundleCount.value = newBlockBundleCount;
@@ -122,6 +190,7 @@ export default async function(adapter, context, $t) {
         mutatedFieldsMap[key] = void 0;
       }
     }
+    fromLibraryUuids.value = fromLibrary;
     eventBus.emit("updateMutatedFields", { fields: newMutatedFields });
     nextTick(() => {
       refreshKey.value = Date.now().toString();
@@ -144,13 +213,61 @@ export default async function(adapter, context, $t) {
     return count;
   }
   function lockBody() {
-    document.body.classList.add("bk-body-loading");
     isLoading.value = true;
   }
   function unlockBody() {
-    document.body.classList.remove("bk-body-loading");
     isLoading.value = false;
   }
+  function getAllUuids(bundle) {
+    if (!bundle) {
+      return [...Object.keys(fieldListItemMap.value)];
+    }
+    return bundleToUuids[bundle] ?? [];
+  }
+  function calculateNestingLevel(uuid) {
+    const cached = nestingLevelMap.get(uuid);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const fieldKey = fieldListItemMap.value[uuid];
+    if (!fieldKey) {
+      nestingLevelMap.set(uuid, 0);
+      return 0;
+    }
+    const field = mutatedFieldsMap[fieldKey];
+    if (!field) {
+      nestingLevelMap.set(uuid, 0);
+      return 0;
+    }
+    const parentEntityUuid = field.entityUuid;
+    const parentFieldKey = fieldListItemMap.value[parentEntityUuid];
+    if (!parentFieldKey) {
+      nestingLevelMap.set(uuid, 0);
+      return 0;
+    }
+    const parentLevel = calculateNestingLevel(parentEntityUuid);
+    const level = parentLevel + 1;
+    nestingLevelMap.set(uuid, level);
+    return level;
+  }
+  function getNestingLevel(uuid) {
+    return nestingLevelMap.get(uuid) ?? 0;
+  }
+  function isChildOf(childUuid, parentUuid) {
+    const fieldKey = fieldListItemMap.value[childUuid];
+    if (!fieldKey) {
+      return false;
+    }
+    const field = mutatedFieldsMap[fieldKey];
+    if (!field) {
+      return false;
+    }
+    if (field.entityUuid === parentUuid) {
+      return true;
+    }
+    return isChildOf(field.entityUuid, parentUuid);
+  }
+  addElementClasses(document.body, "bk-body-loading", isLoading);
   const mutateWithLoadingState = async (callback, errorMessage, successMessage) => {
     if (!callback) {
       return true;
@@ -175,11 +292,13 @@ export default async function(adapter, context, $t) {
       }
       return true;
     } catch (e) {
-      emitMessage(
-        errorMessage || $t("unexpectedMutationError", "An unexpected error happened."),
-        "error",
-        e
-      );
+      if (errorMessage !== false) {
+        emitMessage(
+          errorMessage || $t("unexpectedMutationError", "An unexpected error happened."),
+          "error",
+          e
+        );
+      }
     }
     unlockBody();
     return false;
@@ -199,7 +318,7 @@ export default async function(adapter, context, $t) {
     }
   }
   const canEdit = computed(
-    () => stateLoaded.value && !!owner.value?.currentUserIsOwner && !stateLoadError.value
+    () => stateLoaded.value && !!owner.value?.currentUserIsOwner && !stateLoadError.value && permissions.includes("edit")
   );
   const isTranslation = computed(
     () => context.value.language !== translation.value.sourceLanguage && translation.value.isTranslatable
@@ -228,10 +347,27 @@ export default async function(adapter, context, $t) {
   const stateAvailable = computed(
     () => stateLoaded.value && !stateLoadError.value
   );
+  function getMappedState() {
+    if (!_mappedState) {
+      throw new Error("Called getMappedState() before a state is available.");
+    }
+    return _mappedState;
+  }
+  function setOverrideState(state) {
+    setContext(state, true);
+  }
+  function clearOverrideState() {
+    if (!_mappedState) {
+      throw new Error("Missing previous state.");
+    }
+    setContext(_mappedState);
+  }
   return {
     stateAvailable,
+    getMappedState,
     refreshKey,
     owner: readonly(owner),
+    publishOptions: readonly(publishOptions),
     mutatedFields,
     entity,
     mutatedOptions,
@@ -248,6 +384,14 @@ export default async function(adapter, context, $t) {
     getBlockBundleCount,
     getFieldListItem,
     getMutatedField,
-    getFieldListForBlock
+    getFieldListForBlock,
+    getAllUuids,
+    getNestingLevel,
+    isChildOf,
+    setOverrideState,
+    clearOverrideState,
+    fromLibraryUuids: readonly(fromLibraryUuids),
+    permissions: computed(() => permissions),
+    getFieldKeyForUuid
   };
 }

package/dist/runtime/helpers/storageProvider.d.ts

@@ -1,6 +1,8 @@
-import { type ComputedRef, type WritableComputedRef } from 'vue';
+import { type ComputedRef, type WritableComputedRef } from '#imports';
+import type { AdapterContext, BlokkliAdapter } from '#blokkli/adapter';
 export type StorageProvider = {
-    use: <T>(key: string | ComputedRef<string>, defaultValue: T) => WritableComputedRef<T>;
+    use: <T>(key: string | ComputedRef<string>, defaultValue: T, persist?: boolean) => WritableComputedRef<T>;
+    useWithContextPrefix: <T>(key: string, defaultValue: T, persist?: boolean) => WritableComputedRef<T>;
     clearAll: () => void;
     clear: (key: string) => void;
 };
@@ -12,4 +14,4 @@ export type StorageProvider = {
  * This composable can be used to keep state across page navigations and
  * even after a refresh.
  */
-export default function (): StorageProvider;
+export default function (adapter: BlokkliAdapter<any>, context: ComputedRef<AdapterContext>): Promise<StorageProvider>;

package/dist/runtime/helpers/storageProvider.js

@@ -1,4 +1,9 @@
-import { computed, ref } from "vue";
+import {
+  computed,
+  onBeforeUnmount,
+  ref,
+  watch
+} from "#imports";
 import { storageDefaults } from "#blokkli-build/config";
 const PREFIX = "blokkli:";
 const getExisting = (key) => {
@@ -10,10 +15,53 @@ const getExisting = (key) => {
   } catch {
   }
 };
-export default function() {
+export default async function(adapter, context) {
   const values = ref({});
   const defaults = ref({});
-  const use = (key, providedDefaultValue) => {
+  let timeout = null;
+  const persistableKeys = ref([]);
+  onBeforeUnmount(() => {
+    if (timeout) {
+      window.clearTimeout(timeout);
+    }
+  });
+  const persistedValues = adapter.userSettings ? await adapter.userSettings.load().then((v) => {
+    if (typeof v === "object" && v !== null) {
+      return JSON.stringify(v);
+    }
+    return v;
+  }) : null;
+  if (persistedValues) {
+    values.value = JSON.parse(persistedValues);
+  }
+  const persistableData = computed(() => {
+    const mapped = [...persistableKeys.value].sort().reduce((acc, key) => {
+      const value = values.value[key];
+      if (value !== void 0) {
+        acc[key] = value;
+      }
+      return acc;
+    }, {});
+    return JSON.stringify(mapped);
+  });
+  function persistUserSettings() {
+    if (timeout) {
+      window.clearTimeout(timeout);
+    }
+    timeout = window.setTimeout(async () => {
+      if (!adapter.userSettings) {
+        return;
+      }
+      if (persistableData.value === persistedValues) {
+        return;
+      }
+      await adapter.userSettings.persist(persistableData.value);
+    }, 1e3);
+  }
+  if (adapter.userSettings) {
+    watch(persistableData, persistUserSettings);
+  }
+  const use = (key, providedDefaultValue, persist) => {
     const storageKey = computed(
       () => PREFIX + (typeof key === "string" ? key : key.value)
     );
@@ -30,6 +78,11 @@ export default function() {
         values.value[storageKey.value] = defaultValue;
       }
     }
+    if (persist) {
+      if (!persistableKeys.value.includes(storageKey.value)) {
+        persistableKeys.value.push(storageKey.value);
+      }
+    }
     return computed({
       get() {
         const v = values.value[storageKey.value];
@@ -44,6 +97,10 @@ export default function() {
       }
     });
   };
+  const useWithContextPrefix = (key, providedDefaultValue, persist) => {
+    const fullKey = key + ":" + context.value.entityType + ":" + context.value.entityUuid;
+    return use(fullKey, providedDefaultValue, persist);
+  };
   const clearAll = () => {
     values.value = {};
     Object.keys(window.localStorage).forEach((key) => {
@@ -57,5 +114,5 @@ export default function() {
     values.value[storageKey] = void 0;
     window.localStorage.removeItem(storageKey);
   };
-  return { use, clearAll, clear };
+  return { use, useWithContextPrefix, clearAll, clear };
 }

package/dist/runtime/helpers/symbols.d.ts

@@ -6,6 +6,7 @@ export declare const INJECT_NESTING_LEVEL: unique symbol;
 export declare const INJECT_IS_PREVIEW: unique symbol;
 export declare const INJECT_IS_IN_REUSABLE: unique symbol;
 export declare const INJECT_REUSABLE_OPTIONS: unique symbol;
+export declare const INJECT_REUSABLE_UUID: unique symbol;
 export declare const INJECT_FIELD_LIST_TYPE: unique symbol;
 export declare const INJECT_FIELD_LIST_BLOCKS: unique symbol;
 export declare const INJECT_FIELD_PROXY_MODE: unique symbol;
@@ -17,6 +18,7 @@ export declare const INJECT_MUTATED_FIELDS_MAP: unique symbol;
 export declare const INJECT_ENTITY_CONTEXT: unique symbol;
 export declare const INJECT_PROVIDER_CONTEXT: unique symbol;
 export declare const INJECT_FRAGMENT_CONTEXT: unique symbol;
+export declare const INJECT_PROVIDER_KEY: unique symbol;
 export declare const INJECT_EDIT_FIELD_LIST_COMPONENT: unique symbol;
 export declare const INJECT_EDIT_LOGGER: unique symbol;
 export declare const BK_HIDDEN_GLOBALLY = "bkHiddenGlobally";

package/dist/runtime/helpers/symbols.js

@@ -6,6 +6,7 @@ export const INJECT_NESTING_LEVEL = Symbol("blokkli_nesting_level");
 export const INJECT_IS_PREVIEW = Symbol("blokkli_is_preview");
 export const INJECT_IS_IN_REUSABLE = Symbol("blokkli_is_in_reusable");
 export const INJECT_REUSABLE_OPTIONS = Symbol("blokkli_from_library_options");
+export const INJECT_REUSABLE_UUID = Symbol("blokkli_from_library_uuid");
 export const INJECT_FIELD_LIST_TYPE = Symbol("blokkli_field_list_type");
 export const INJECT_FIELD_LIST_BLOCKS = Symbol("blokkli_field_list_blocks");
 export const INJECT_FIELD_PROXY_MODE = Symbol("blokkli_field_proxy_mode");
@@ -17,6 +18,7 @@ export const INJECT_MUTATED_FIELDS_MAP = Symbol("blokkli_mutated_fields_map");
 export const INJECT_ENTITY_CONTEXT = Symbol("blokkli_entity_context");
 export const INJECT_PROVIDER_CONTEXT = Symbol("blokkli_provider_context");
 export const INJECT_FRAGMENT_CONTEXT = Symbol("blokkli_fragment_context");
+export const INJECT_PROVIDER_KEY = Symbol("blokkli_provider_key");
 export const INJECT_EDIT_FIELD_LIST_COMPONENT = Symbol(
   "blokkli_edit_field_list_component"
 );

package/dist/runtime/helpers/textProvider.js

@@ -1,6 +1,7 @@
 import { computed } from "vue";
 import { translations } from "#blokkli-build/translations";
 import { defaultLanguage, forceDefaultLanguage } from "#blokkli-build/config";
+const DEBUG_SWISS_GERMAN = false;
 export default function(context) {
   const language = computed(() => {
     if (forceDefaultLanguage) {
@@ -12,6 +13,11 @@ export default function(context) {
     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 translations.gsw_CH || translations[language.value] || {};
+    }
     return translations[language.value] || {};
   });
   return (key, defaultValue) => {

package/dist/runtime/helpers/themeProvider.d.ts

@@ -1,6 +1,7 @@
 import type { DraggableStyle } from '#blokkli/types';
 import type { RGB, ThemeColorGroup, ThemeColorShade, ThemeColors, ThemeContextColorGroup, ThemeContextColorShade, ThemeContextColors, ThemeName } from '#blokkli/types/theme';
 import { type Ref } from '#imports';
+import type { ElementProvider } from './providers/element.js';
 type ThemeMap = {
     accent: Ref<ThemeColors>;
     mono: Ref<ThemeColors>;
@@ -8,6 +9,7 @@ type ThemeMap = {
     yellow: Ref<ThemeContextColors>;
     red: Ref<ThemeContextColors>;
     lime: Ref<ThemeContextColors>;
+    orange: Ref<ThemeContextColors>;
 };
 export type ThemeProvider = {
     accent: Ref<ThemeColors>;
@@ -16,6 +18,7 @@ export type ThemeProvider = {
     yellow: Ref<ThemeContextColors>;
     red: Ref<ThemeContextColors>;
     lime: Ref<ThemeContextColors>;
+    orange: Ref<ThemeContextColors>;
     getDraggableStyle: (el: HTMLElement | SVGElement) => DraggableStyle;
     setColor: <Group extends ThemeColorGroup | ThemeContextColorGroup>(group: Group, shade: Group extends ThemeColorGroup ? ThemeColorShade : ThemeContextColorShade, value: RGB) => void;
     applyTheme: (name: ThemeName | 'custom') => void;
@@ -23,5 +26,5 @@ export type ThemeProvider = {
     getColor<K extends keyof ThemeMap, T extends ThemeMap[K]['value']>(color: K, key: keyof T): RGB;
     getColorString<K extends keyof ThemeMap, T extends ThemeMap[K]['value']>(color: K, key: keyof T, alpha?: number): string;
 };
-export default function (): ThemeProvider;
+export default function (element: ElementProvider): ThemeProvider;
 export {};

package/dist/runtime/helpers/themeProvider.js

@@ -3,7 +3,15 @@ import { ref, onMounted, onBeforeUnmount } from "#imports";
 import { rgbaToString } from "./index.js";
 import { DragStyle } from "./DragStyle/index.js";
 import onBlokkliEvent from "./composables/onBlokkliEvent.js";
-export default function() {
+export default function(element) {
+  const rootElement = element.query(
+    document,
+    ":root",
+    "Get document root element for setting theme color."
+  );
+  if (!rootElement) {
+    throw new Error("Failed to query :root - is this even possible?");
+  }
   const originalBrowserThemeColor = ref("");
   const THEME_COLOR = "black";
   const accent = ref(theme.accent);
@@ -12,13 +20,15 @@ export default function() {
   const yellow = ref(theme.yellow);
   const red = ref(theme.red);
   const lime = ref(theme.lime);
+  const orange = ref(theme.orange);
   const themeMap = {
     accent,
     mono,
     teal,
     yellow,
     red,
-    lime
+    lime,
+    orange
   };
   function getColor(color, key) {
     return themeMap[color].value[key];
@@ -42,13 +52,10 @@ export default function() {
     } else if (group === "lime") {
       lime.value[shade] = value;
     }
-    const root = document.querySelector(":root");
-    if (root instanceof HTMLElement) {
-      root.style.setProperty(
-        `--bk-theme-${group}-${shade}`,
-        `${value[0]} ${value[1]} ${value[2]}`
-      );
-    }
+    rootElement.style.setProperty(
+      `--bk-theme-${group}-${shade}`,
+      `${value[0]} ${value[1]} ${value[2]}`
+    );
   };
   const setColorsFromTheme = (v) => {
     Object.entries(v).forEach(([group, colors]) => {
@@ -77,7 +84,11 @@ export default function() {
     }
   };
   onMounted(() => {
-    const el = document.head.querySelectorAll('[name="theme-color"]');
+    const el = element.query(
+      document.head,
+      '[name="theme-color"]',
+      "Theme: theme-color"
+    );
     if (el instanceof HTMLMetaElement) {
       originalBrowserThemeColor.value = el.content;
       el.content = THEME_COLOR;
@@ -85,14 +96,15 @@ export default function() {
       const meta = document.createElement("meta");
       meta.name = "theme-color";
       meta.content = THEME_COLOR;
-      const head = document.getElementsByTagName("head")[0];
-      if (head) {
-        head.appendChild(meta);
-      }
+      document.head.appendChild(meta);
     }
   });
   onBeforeUnmount(() => {
-    const el = document.head.querySelectorAll('[name="theme-color"]');
+    const el = element.query(
+      document.head,
+      '[name="theme-color"]',
+      "Theme: theme-color"
+    );
     if (el instanceof HTMLMetaElement) {
       if (originalBrowserThemeColor.value) {
         el.content = originalBrowserThemeColor.value;
@@ -115,6 +127,7 @@ export default function() {
     yellow,
     red,
     lime,
+    orange,
     getDraggableStyle: function(el) {
       return dragStyle.getStyle(el, theme.accent[700]);
     },

package/dist/runtime/helpers/transform.js

@@ -6,9 +6,7 @@ export function filterTransforms(plugins, selectedItems, selectedBundles, allowe
     if (plugin.max !== -1 && selectedItems.length > plugin.max) {
       return false;
     }
-    const allAllowedInList = plugin.targetBundles.every(
-      (bundle) => allowedBundles.includes(bundle)
-    );
+    const allAllowedInList = !plugin.targetBundles || plugin.targetBundles.every((bundle) => allowedBundles.includes(bundle));
     if (!allAllowedInList) {
       return false;
     }