@blokkli/editor 2.0.0-alpha.5 → 2.0.0-alpha.50

package/dist/runtime/helpers/index.js

@@ -1,479 +1,9 @@
-import { easeOutSine } from "./easing.js";
-import { useRuntimeConfig } from "#imports";
 export function falsy(value) {
   return value !== null && value !== void 0;
 }
-export function buildDraggableItem(element) {
-  if (!(element instanceof HTMLElement)) {
-    return;
-  }
-  const itemEntityType = useRuntimeConfig().public.blokkli.itemEntityType;
-  const dataset = element.dataset;
-  if (dataset.elementType === "existing") {
-    const uuid = dataset.uuid;
-    const itemBundle = dataset.itemBundle;
-    const entityType = dataset.entityType;
-    const hostType = dataset.hostType;
-    const hostUuid = dataset.hostUuid;
-    const hostBundle = dataset.hostBundle;
-    const hostFieldName = dataset.hostFieldName;
-    const reusableBundle = dataset.reusableBundle;
-    const hostFieldListType = dataset.hostFieldListType;
-    const libraryItemUuid = dataset.bkLibraryItemUuid;
-    const isNew = dataset.isNew === "true";
-    const parentBlockBundle = hostType === itemEntityType ? hostBundle : void 0;
-    if (uuid && hostType && hostUuid && hostFieldName && itemBundle && hostBundle && entityType && hostFieldListType) {
-      const libraryLabel = dataset.bkLibraryLabel;
-      const editTitle = libraryLabel || "";
-      return {
-        itemType: "existing",
-        element: () => document.querySelector(`[data-uuid="${uuid}"]`),
-        itemBundle,
-        entityType,
-        isNested: hostType === itemEntityType,
-        uuid,
-        hostType,
-        hostBundle,
-        hostUuid,
-        hostFieldName,
-        hostFieldListType,
-        reusableBundle,
-        libraryItemUuid,
-        editTitle: editTitle || void 0,
-        isNew,
-        parentBlockBundle
-      };
-    }
-  } else if (dataset.elementType === "new") {
-    const itemBundle = dataset.itemBundle;
-    if (itemBundle) {
-      return {
-        itemType: "new",
-        element: () => document.querySelector(
-          `[data-sortli-id="${itemBundle}"]`
-        ),
-        itemBundle
-      };
-    }
-  } else if (dataset.elementType === "action") {
-    const actionType = dataset.actionType;
-    const itemBundle = dataset.itemBundle;
-    if (actionType) {
-      return {
-        itemType: "action",
-        actionType,
-        itemBundle,
-        element: () => document.querySelector(
-          `[data-element-type="action"][data-sortli-id="${actionType}"]`
-        )
-      };
-    }
-  } else if (dataset.elementType === "clipboard") {
-    const additional = dataset.clipboardAdditional;
-    const itemBundle = dataset.itemBundle;
-    const clipboardId = dataset.clipboardId;
-    const id = dataset.sortliId;
-    if (itemBundle && clipboardId) {
-      return {
-        itemType: "clipboard",
-        element: () => document.querySelector(`[data-sortli-id="${id}"]`),
-        itemBundle,
-        additional,
-        clipboardId
-      };
-    }
-  } else if (dataset.elementType === "media_library") {
-    const mediaId = dataset.mediaId;
-    const itemBundle = dataset.itemBundle;
-    const mediaBundle = dataset.mediaBundle;
-    if (mediaId && itemBundle && mediaBundle) {
-      return {
-        itemType: "media_library",
-        mediaId,
-        itemBundle,
-        mediaBundle,
-        element: () => document.querySelector(
-          `[data-element-type="media_library"][data-media-id="${mediaId}"]`
-        )
-      };
-    }
-  } else if (dataset.elementType === "search_content") {
-    const searchItemData = dataset.searchItem;
-    const id = dataset.sortliId;
-    if (searchItemData && id) {
-      const searchItem = JSON.parse(searchItemData);
-      return {
-        itemType: "search_content",
-        element: () => document.querySelector(`[data-sortli-id="${id}"]`),
-        itemBundle: searchItem.targetBundles[0],
-        searchItem
-      };
-    }
-  }
-}
-export function findElement(uuid) {
-  const el = document.querySelector(
-    `[data-uuid="${uuid}"]:not(.bk-sortli-leave-from)`
-  );
-  if (el instanceof HTMLElement) {
-    return el;
-  }
-}
 export function onlyUnique(value, index, self) {
   return self.indexOf(value) === index;
 }
-export function getRelativeTimeString(date, lang = navigator.language) {
-  const timeMs = typeof date === "number" ? date : date.getTime();
-  const deltaSeconds = Math.round((timeMs - Date.now()) / 1e3);
-  const cutoffs = [
-    60,
-    3600,
-    86400,
-    86400 * 7,
-    86400 * 30,
-    86400 * 365,
-    Infinity
-  ];
-  const units = [
-    "second",
-    "minute",
-    "hour",
-    "day",
-    "week",
-    "month",
-    "year"
-  ];
-  const unitIndex = cutoffs.findIndex(
-    (cutoff) => cutoff > Math.abs(deltaSeconds)
-  );
-  const divisor = unitIndex ? cutoffs[unitIndex - 1] : 1;
-  const rtf = new Intl.RelativeTimeFormat(lang, { numeric: "auto" });
-  return rtf.format(Math.floor(deltaSeconds / divisor), units[unitIndex]);
-}
-export function modulo(n, m) {
-  return (n % m + m) % m;
-}
-export function getBounds(rects) {
-  if (!rects.length) {
-    return;
-  }
-  const firstRect = rects[0];
-  let minX = firstRect.x;
-  let minY = firstRect.y;
-  let maxX = minX + firstRect.width;
-  let maxY = minY + firstRect.height;
-  for (const rect of rects.slice(1)) {
-    minX = Math.min(minX, rect.x);
-    minY = Math.min(minY, rect.y);
-    maxX = Math.max(maxX, rect.x + rect.width);
-    maxY = Math.max(maxY, rect.y + rect.height);
-  }
-  return {
-    x: minX,
-    y: minY,
-    width: maxX - minX,
-    height: maxY - minY
-  };
-}
-export function intersects(a, b) {
-  return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
-}
-export function isInsideRect(x, y, rect) {
-  return x > rect.x && x < rect.x + rect.width && y > rect.y && y < rect.y + rect.height;
-}
-export function calculateIntersection(rectA, rectB) {
-  if (!intersects(rectA, rectB)) {
-    return 0;
-  }
-  const xOverlap = Math.max(
-    0,
-    Math.min(rectA.x + rectA.width, rectB.x + rectB.width) - Math.max(rectA.x, rectB.x)
-  );
-  const yOverlap = Math.max(
-    0,
-    Math.min(rectA.y + rectA.height, rectB.y + rectB.height) - Math.max(rectA.y, rectB.y)
-  );
-  const intersectionArea = xOverlap * yOverlap;
-  const rectAArea = rectA.width * rectA.height;
-  return intersectionArea / rectAArea;
-}
-export function findClosestRectangle(x, y, rects) {
-  let closestRect = rects[0];
-  if (!closestRect) {
-    throw new Error("Need at least one rect.");
-  }
-  let minDistance = distanceToClosestRectangleEdge(x, y, closestRect);
-  for (let i = 1; i < rects.length; i++) {
-    const rect = rects[i];
-    const distance = distanceToClosestRectangleEdge(x, y, rect);
-    if (distance < minDistance) {
-      closestRect = rect;
-      minDistance = distance;
-    }
-  }
-  return closestRect;
-}
-export function distanceToRectangle(x, y, rect) {
-  const minX = rect.x;
-  const minY = rect.y;
-  const maxX = rect.x + rect.width;
-  const maxY = rect.y + rect.height;
-  const dx = Math.max(minX - x, 0, x - maxX);
-  const dy = Math.max(minY - y, 0, y - maxY);
-  return Math.sqrt(dx * dx + dy * dy);
-}
-export function distanceToClosestRectangleEdge(x, y, rect) {
-  if (isInsideRect(x, y, rect)) {
-    return 0;
-  }
-  const minX = rect.x;
-  const minY = rect.y;
-  const maxX = rect.x + rect.width;
-  const maxY = rect.y + rect.height;
-  const dx = Math.max(minX - x, 0, x - maxX);
-  const dy = Math.max(minY - y, 0, y - maxY);
-  return Math.sqrt(dx * dx + dy * dy);
-}
-export function getDistance(a, b) {
-  const dx = a.x - b.x;
-  const dy = a.y - b.y;
-  return Math.sqrt(dx * dx + dy * dy);
-}
-export const parseColorString = (color) => {
-  const rgbaRegex = /^rgba?\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})(?:,\s*(0|1|0?\.\d+))?\)$/;
-  const match = color.match(rgbaRegex);
-  if (!match) {
-    return;
-  }
-  const r = Number.parseInt(match[1]);
-  const g = Number.parseInt(match[2]);
-  const b = Number.parseInt(match[3]);
-  const a = match[4] !== void 0 ? Number.parseFloat(match[4]) : 1;
-  if ([r, g, b, a].some((val) => Number.isNaN(val))) {
-    throw new Error("Invalid color values");
-  }
-  if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
-    return;
-  }
-  return [r, g, b];
-};
-export const realBackgroundColor = (el) => {
-  const transparent = "rgba(0, 0, 0, 0)";
-  if (!el) return transparent;
-  const bg = getComputedStyle(el).backgroundColor;
-  if (bg === transparent || bg === "transparent") {
-    return realBackgroundColor(el.parentElement);
-  }
-  return bg;
-};
-export const lerp = (s, e, t) => s * (1 - t) + e * t;
-export const calculateCenterPosition = (blockingRects, viewport, widthToPlace) => {
-  const viewportCenterX = (viewport.x + viewport.width) / 2;
-  const blockingThreshold = viewport.width / 7;
-  const x = blockingRects.reduce((acc, rect) => {
-    if (rect.x < viewportCenterX && viewportCenterX - rect.x > blockingThreshold && rect.x + rect.width > acc) {
-      return rect.x + rect.width;
-    }
-    return acc;
-  }, viewport.x);
-  const width = blockingRects.reduce((acc, rect) => {
-    if (rect.x > viewportCenterX && rect.x - viewportCenterX > blockingThreshold && rect.x < acc) {
-      return rect.x;
-    }
-    return acc;
-  }, viewport.width + viewport.x);
-  return (x + width) / 2 - widthToPlace / 2;
-};
-export function getContrastRatio(color1, color2) {
-  const luminance1 = getLuminance(color1);
-  const luminance2 = getLuminance(color2);
-  const lighter = Math.max(luminance1, luminance2);
-  const darker = Math.min(luminance1, luminance2);
-  return (lighter + 0.05) / (darker + 0.05);
-}
-function getLuminance(color) {
-  const [r, g, b] = color.map((val) => {
-    val /= 255;
-    return val <= 0.03928 ? val / 12.92 : Math.pow((val + 0.055) / 1.055, 2.4);
-  });
-  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
-}
-export function findHighestContrastColor(colors, backgroundColor = [255, 255, 255]) {
-  let maxContrast = 0;
-  let maxContrastColor = colors[0];
-  for (const color of colors) {
-    const contrast = getContrastRatio(color, backgroundColor);
-    if (contrast > maxContrast) {
-      maxContrast = contrast;
-      maxContrastColor = color;
-    }
-  }
-  return maxContrastColor;
-}
-export const rgbaToString = (color, alpha = 1) => `rgba(${[...color, alpha].join(", ")})`;
-export const getNumericStyleValue = (str, fallback = 0) => {
-  const v = str.replace("px", "");
-  const num = Number.parseFloat(v);
-  if (Number.isNaN(num) || num === 0) {
-    return fallback;
-  }
-  return num;
-};
-export function findIdealRectPosition(blockingRects, rectToPlace, viewport, maxOverlap = 60) {
-  let targetX = rectToPlace.x;
-  for (const blockingRect of blockingRects) {
-    if (intersects(rectToPlace, blockingRect)) {
-      const a = Math.abs(rectToPlace.y + rectToPlace.height - blockingRect.y);
-      const b = Math.abs(blockingRect.y + blockingRect.height - rectToPlace.y);
-      const verticalOverlap = Math.min(a, b);
-      const smoothingFactor = easeOutSine(
-        Math.min(verticalOverlap, maxOverlap) / maxOverlap
-      );
-      if (rectToPlace.x + rectToPlace.width / 2 > blockingRect.x + blockingRect.width / 2) {
-        targetX = blockingRect.x + blockingRect.width;
-      } else {
-        targetX = blockingRect.x - rectToPlace.width;
-      }
-      targetX = rectToPlace.x + smoothingFactor * (targetX - rectToPlace.x);
-      break;
-    }
-  }
-  return {
-    x: Math.min(
-      Math.max(targetX, viewport.x),
-      viewport.x + viewport.width - rectToPlace.width
-    ),
-    y: Math.min(
-      Math.max(viewport.y, rectToPlace.y),
-      viewport.height + viewport.y - rectToPlace.height
-    )
-  };
-}
-export const findClosestBlock = (el) => {
-  if (!(el instanceof Element)) {
-    return;
-  }
-  const closest = el.closest('[data-element-type="existing"]');
-  if (!closest) {
-    return;
-  }
-  const item = buildDraggableItem(closest);
-  if (item?.itemType !== "existing") {
-    return;
-  }
-  return item;
-};
-export const findClosestEntityContext = (el) => {
-  const provider = el.closest('[data-blokkli-provider-active="true"]');
-  if (!(provider instanceof HTMLElement)) {
-    return;
-  }
-  const uuid = provider.dataset.providerUuid;
-  const type = provider.dataset.providerEntityType;
-  const bundle = provider.dataset.providerEntityBundle;
-  if (uuid && type && bundle) {
-    return {
-      uuid,
-      type,
-      bundle
-    };
-  }
-};
-export const findParentContext = (el) => {
-  const block = findClosestBlock(el);
-  if (block) {
-    return block;
-  }
-  return findClosestEntityContext(el);
-};
-export const mapDroppableField = (el) => {
-  if (!(el instanceof HTMLElement)) {
-    throw new TypeError(
-      `v-blokkli-droppable directive is only allowed on elements of type HTMLElement.`
-    );
-  }
-  const fieldName = el.dataset.blokkliDroppableField;
-  if (!fieldName) {
-    throw new Error(`Missing field name in v-blokkli-droppable directive.`);
-  }
-  const host = findParentContext(el);
-  if (!host) {
-    throw new Error(
-      `Failed to locate parent context for v-blokkli-droppable field with name "${fieldName}". Make sure the element is always rendered inside a block component or inside a <BlokkliProvider>.`
-    );
-  }
-  return {
-    element: el,
-    host,
-    fieldName
-  };
-};
-export const originatesFromEditable = (e) => {
-  if (e.target instanceof HTMLElement) {
-    const el = e.target.closest("[data-blokkli-editable-field]");
-    if (el instanceof HTMLElement) {
-      return el;
-    }
-  }
-};
-export const getOriginatingDroppableElement = (e) => {
-  if (e.target instanceof HTMLElement) {
-    const el = e.target.closest("[data-blokkli-droppable-field]");
-    if (el instanceof HTMLElement) {
-      return el;
-    }
-  }
-};
-export const originatesFromTextInput = (e) => e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement;
 export function getFieldKey(uuid, fieldName) {
   return uuid + ":" + fieldName;
 }
-export function getInteractionCoordinates(e) {
-  if ("touches" in e) {
-    const touch = e.touches[0] || e.changedTouches[0];
-    return {
-      x: touch.clientX,
-      y: touch.clientY
-    };
-  }
-  return {
-    x: e.clientX,
-    y: e.clientY
-  };
-}
-export function toShaderColor(rgba) {
-  return rgba.map((v) => v / 255);
-}
-export function generateUUID() {
-  try {
-    return crypto.randomUUID();
-  } catch {
-  }
-  let d = (/* @__PURE__ */ new Date()).getTime(), d2 = typeof performance !== "undefined" && performance.now && performance.now() * 1e3 || 0;
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    let r = Math.random() * 16;
-    if (d > 0) {
-      r = (d + r) % 16 | 0;
-      d = Math.floor(d / 16);
-    } else {
-      r = (d2 + r) % 16 | 0;
-      d2 = Math.floor(d2 / 16);
-    }
-    return (c == "x" ? r : r & 7 | 8).toString(16);
-  });
-}
-export function buildAttributesForLibraryItem(props) {
-  return {
-    "data-reusable-bundle": props.block?.bundle,
-    "data-reusable-uuid": props.block?.uuid,
-    "data-bk-library-label": props.label,
-    "data-bk-library-item-uuid": props.uuid,
-    "data-blokkli-is-reusable": "true"
-  };
-}
-export function asValidNumber(v, defaultValue) {
-  if (typeof v === "number" && !Number.isNaN(v)) {
-    return v;
-  }
-  return defaultValue;
-}

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

@@ -0,0 +1,136 @@
+import type { InjectionKey, ComputedRef, Component } from 'vue';
+import type { EntityContext } from './../types/index.js';
+import type { DebugLogger } from '#blokkli/editor/providers/debug';
+import type { FieldListItemTyped, ValidFieldListTypes, ValidProviderTypes } from '#blokkli-build/generated-types';
+import type DraggableListComponent from '../editor/components/DraggableList.vue.js';
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { MutatedField, MutatedItemProps, MutatedOptions } from '#blokkli/editor/types/state';
+import type { DefineBlokkliContext } from '#blokkli/types/definitions';
+import type { InjectedBlokkliItem } from '#blokkli/types/field';
+import type { Eventbus } from '#blokkli/editor/events';
+import type { DomProvider } from '#blokkli/editor/providers/dom';
+import type { DefinitionProvider } from '#blokkli/editor/providers/definition';
+import type { BlokkliProviderEntityContext } from '#blokkli/types/provider';
+type ItemEditContext = {
+    eventBus: Eventbus;
+    mutatedOptions: MutatedOptions;
+    dom?: DomProvider;
+    definitions: DefinitionProvider;
+    useBlockRegistration?: (dom: DomProvider, uuid: string) => void;
+};
+export declare const INJECT_APP: InjectionKey<BlokkliApp>;
+/**
+ * The reduced edit context.
+ */
+export declare const INJECT_EDIT_CONTEXT: InjectionKey<ItemEditContext | null>;
+/**
+ * Whether we're currently editing (within the editor).
+ */
+export declare const INJECT_IS_EDITING: InjectionKey<boolean>;
+/**
+ * Whether the block is rendered within another block (nested).
+ */
+export declare const INJECT_IS_NESTED: InjectionKey<boolean>;
+/**
+ * The current nesting level, starting at 0.
+ */
+export declare const INJECT_NESTING_LEVEL: InjectionKey<number>;
+/**
+ * The z-index of the parent field, used to resolve overlapping blocks at the
+ * same nesting level. Higher values take priority.
+ */
+export declare const INJECT_FIELD_Z_INDEX: InjectionKey<number>;
+/**
+ * Whether we're currently in preview mode.
+ */
+export declare const INJECT_IS_PREVIEW: InjectionKey<ComputedRef<boolean>>;
+/**
+ * Whether the block is rendered inside a from_library block.
+ */
+export declare const INJECT_IS_IN_REUSABLE: InjectionKey<boolean>;
+/**
+ * The options provided by the from_library block.
+ */
+export declare const INJECT_REUSABLE_OPTIONS: InjectionKey<ComputedRef<Record<string, string | number | boolean | string[] | undefined>>>;
+/**
+ * The UUID of the parent from_library block.
+ */
+export declare const INJECT_REUSABLE_UUID: InjectionKey<string>;
+/**
+ * The field list type of the parent field.
+ */
+export declare const INJECT_FIELD_LIST_TYPE: InjectionKey<ComputedRef<ValidFieldListTypes>>;
+/**
+ * The field list items of the containing block.
+ */
+export declare const INJECT_FIELD_LIST_BLOCKS: InjectionKey<ComputedRef<FieldListItemTyped[]>>;
+/**
+ * Whether the parent field is rendering in proxy mode.
+ */
+export declare const INJECT_FIELD_PROXY_MODE: InjectionKey<boolean>;
+/**
+ * Whether the parent field is rendering in proxy mode.
+ *
+ * @todo: This is probably the ssame as INJECT_FIELD_PROXY_MODE.
+ */
+export declare const INJECT_FIELD_USES_PROXY: InjectionKey<boolean>;
+/**
+ * Whether the global proxy mode setting is enabled in the editor.
+ */
+export declare const INJECT_GLOBAL_PROXY_MODE: InjectionKey<ComputedRef<boolean>>;
+/**
+ * The blocks of the root field.
+ */
+export declare const INJECT_PROVIDER_BLOCKS: InjectionKey<ComputedRef<FieldListItemTyped[]>>;
+/**
+ * The item data provided by BlokkliItem.
+ */
+export declare const INJECT_BLOCK_ITEM: InjectionKey<ComputedRef<InjectedBlokkliItem>>;
+/**
+ * The mutated fields map provided in the editor.
+ *
+ * This is a reactive property with an objected keyed by field list key.
+ */
+export declare const INJECT_MUTATED_FIELDS_MAP: InjectionKey<Record<string, MutatedField | undefined>>;
+/**
+ * The current "entity context".
+ *
+ * For blocks rendered directly within the first BlokkliField inside BlokkliProvider, the entity is the provider.
+ * For nested blocks, the entity context will be the block that contains nested blocks.
+ */
+export declare const INJECT_ENTITY_CONTEXT: InjectionKey<EntityContext>;
+/**
+ * The current provider type.
+ */
+export declare const INJECT_PROVIDER_TYPE: InjectionKey<ValidProviderTypes>;
+/**
+ * The entity context of the provider.
+ */
+export declare const INJECT_PROVIDER_CONTEXT: InjectionKey<ComputedRef<BlokkliProviderEntityContext>>;
+/**
+ * The defineBlokkli context of the "blokkli_fragment" block.
+ */
+export declare const INJECT_FRAGMENT_CONTEXT: InjectionKey<DefineBlokkliContext<any, any>>;
+/**
+ * The unique key of the current provider.
+ */
+export declare const INJECT_PROVIDER_KEY: InjectionKey<string>;
+/**
+ * The DraggableList component used during editing.
+ */
+export declare const INJECT_EDIT_FIELD_LIST_COMPONENT: InjectionKey<typeof DraggableListComponent>;
+/**
+ * The reactive item props override object, used to override props values (during editing).
+ */
+export declare const INJECT_ITEM_PROPS_OVERRIDE: InjectionKey<MutatedItemProps>;
+/**
+ * The debug logger instance.
+ */
+export declare const INJECT_EDIT_LOGGER: InjectionKey<DebugLogger>;
+/**
+ * An object containing block item component keys as properties and the Vue component as values.
+ *
+ * Used to prevent async loading of components in the editor.
+ */
+export declare const INJECT_ALL_COMPONENTS_CHUNK: InjectionKey<Record<string, Component>>;
+export {};

package/dist/runtime/helpers/injections.js

@@ -0,0 +1,75 @@
+export const INJECT_APP = Symbol("blokkli_app");
+export const INJECT_EDIT_CONTEXT = Symbol(
+  "blokkli_edit_context"
+);
+export const INJECT_IS_EDITING = Symbol(
+  "blokkli_is_editing"
+);
+export const INJECT_IS_NESTED = Symbol(
+  "blokkli_is_nested"
+);
+export const INJECT_NESTING_LEVEL = Symbol(
+  "blokkli_nesting_level"
+);
+export const INJECT_FIELD_Z_INDEX = Symbol(
+  "blokkli_field_z_index"
+);
+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"
+);
+export const INJECT_FIELD_USES_PROXY = Symbol(
+  "blokkli_field_uses_proxy"
+);
+export const INJECT_GLOBAL_PROXY_MODE = Symbol(
+  "blokkli_global_proxy_mode"
+);
+export const INJECT_PROVIDER_BLOCKS = Symbol(
+  "blokkli_provider_blocks"
+);
+export const INJECT_BLOCK_ITEM = Symbol("blokkli_block_item");
+export const INJECT_MUTATED_FIELDS_MAP = Symbol(
+  "blokkli_mutated_fields_map"
+);
+export const INJECT_ENTITY_CONTEXT = Symbol(
+  "blokkli_entity_context"
+);
+export const INJECT_PROVIDER_TYPE = Symbol(
+  "blokkli_provider_type"
+);
+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"
+);
+export const INJECT_ITEM_PROPS_OVERRIDE = Symbol(
+  "blokkli_edit_item_props_override"
+);
+export const INJECT_EDIT_LOGGER = Symbol(
+  "blokkli_edit_logger"
+);
+export const INJECT_ALL_COMPONENTS_CHUNK = Symbol(
+  "blokkli_all_components_chunk"
+);

package/dist/runtime/helpers/runtimeHelpers/index.d.ts

@@ -1,9 +1,10 @@
 /**
  * This file should contain all helpers that are meant for runtime functionality, such as defineBlokkli composable or <BlokkliProvider>.
  */
-import { type RuntimeBlockOptionArray, type RuntimeBlockOptions } from '#blokkli-build/runtime-options';
+import { type RuntimeBlockOptions } from '#blokkli-build/runtime-options';
 import type { FieldListItemTyped } from '#blokkli-build/generated-types';
-import type { BlockOptionDefinition } from '#blokkli/types/blokkOptions';
+import type { BlockOptionDefinition } from '#blokkli/types/blockOptions';
+import type { RuntimeBlockOptionArray } from '../../../global/types/blockOptions.js';
 import type { FieldListItem } from '#blokkli/types';
 /**
  * Map all kinds of truthy values for a checkbox.