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

package/dist/runtime/helpers/dom/index.js

@@ -1,37 +0,0 @@
-export function cloneWithInlineStyles(node) {
-  const clone = node.cloneNode(false);
-  clone.removeAttribute("class");
-  clone.removeAttribute("id");
-  clone.removeAttribute("name");
-  clone.removeAttribute("for");
-  clone.removeAttribute("style");
-  if (clone instanceof HTMLElement || clone instanceof SVGElement) {
-    Object.keys(clone.dataset).forEach((key) => {
-      clone.dataset[key] = "";
-    });
-  }
-  const computedStyle = getComputedStyle(node);
-  for (let i = 0; i < computedStyle.length; i++) {
-    const propName = computedStyle[i];
-    if (clone instanceof HTMLElement || clone instanceof SVGElement) {
-      clone.style[propName] = computedStyle.getPropertyValue(propName);
-    }
-  }
-  Array.from(node.childNodes).forEach((child) => {
-    if (child.nodeType === Node.ELEMENT_NODE) {
-      clone.appendChild(cloneWithInlineStyles(child));
-    } else if (child.nodeType === Node.TEXT_NODE) {
-      clone.appendChild(child.cloneNode(true));
-    }
-  });
-  return clone;
-}
-export function cloneElementWithStyles(element, isRoot) {
-  const clonedElement = cloneWithInlineStyles(element);
-  if (isRoot && (clonedElement instanceof HTMLElement || clonedElement instanceof SVGElement)) {
-    clonedElement.style.opacity = "1";
-  }
-  const container = document.createElement("div");
-  container.appendChild(clonedElement);
-  return container.innerHTML;
-}

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

@@ -1,51 +0,0 @@
-import { type ComputedRef } from '#imports';
-import type { DraggableExistingBlock, BlokkliFieldElement, DraggableItem, DroppableEntityField, EntityContext, Rectangle } from '#blokkli/types';
-import type { UiProvider } from './uiProvider.js';
-import type { DebugProvider } from './debugProvider.js';
-import type { DefinitionProvider } from './definitionProvider.js';
-type RegisteredFieldType = {
-    entityType: string;
-    entityBundle: string;
-    fieldName: string;
-};
-type MeasuredBlockRect = Rectangle & {
-    time: number;
-};
-export type DomProvider = {
-    findBlock(uuid: string): DraggableExistingBlock | undefined;
-    getAllBlocks(): DraggableExistingBlock[];
-    findClosestBlock(el: Element | EventTarget): DraggableExistingBlock | undefined;
-    /**
-     * Return the droppable markup for a draggable item.
-     */
-    getDropElementMarkup(item: DraggableItem, checkSize?: boolean): string;
-    findField(entityUuid: string, fieldName: string): BlokkliFieldElement | undefined;
-    registerBlock: (key: string, uuid: string, el: HTMLElement | null) => void;
-    unregisterBlock: (key: string, uuid: string) => void;
-    registerField: (entity: EntityContext, fieldName: string, instance: HTMLElement) => void;
-    updateFieldElement: (entity: EntityContext, fieldName: string, element: HTMLElement) => void;
-    unregisterField: (entity: EntityContext, fieldName: string) => void;
-    registeredFieldTypes: ComputedRef<RegisteredFieldType[]>;
-    /**
-     * Get all droppable entity fields.
-     */
-    getAllDroppableFields(): DroppableEntityField[];
-    findClosestEntityContext(el: HTMLElement): EntityContext | undefined;
-    getVisibleBlocks(): string[];
-    getVisibleFields(): string[];
-    isBlockVisible(uuid: string): boolean;
-    getActiveProviderElement: () => HTMLElement;
-    getBlockRects: () => Record<string, MeasuredBlockRect>;
-    getBlockRect: (uuid: string) => MeasuredBlockRect | undefined;
-    refreshBlockRect: (uuid: string) => void;
-    getFieldRect: (key: string) => Rectangle | undefined;
-    updateVisibleRects: () => void;
-    isReady: ComputedRef<boolean>;
-    init: () => void;
-    /**
-     * Get the drag element for a block.
-     */
-    getDragElement: (block: DraggableExistingBlock) => HTMLElement | undefined;
-};
-export default function (ui: UiProvider, debug: DebugProvider, definitions: DefinitionProvider): DomProvider;
-export {};

package/dist/runtime/helpers/domProvider.js

@@ -1,452 +0,0 @@
-import { reactive, ref, computed } from "#imports";
-import {
-  findClosestBlock,
-  buildDraggableItem,
-  falsy,
-  mapDroppableField,
-  findClosestEntityContext
-} from "#blokkli/helpers";
-import { cloneElementWithStyles } from "./dom/index.js";
-import onBlokkliEvent from "./composables/onBlokkliEvent.js";
-import useDelayedIntersectionObserver from "./composables/useDelayedIntersectionObserver.js";
-const buildFieldElement = (element) => {
-  const key = element.dataset.fieldKey;
-  const name = element.dataset.fieldName;
-  const label = element.dataset.fieldLabel;
-  const isNested = element.dataset.fieldIsNested === "true";
-  const nestingLevel = Number.parseInt(element.dataset.bkNestingLevel || "0");
-  const fieldListType = element.dataset.fieldListType;
-  const hostEntityType = element.dataset.hostEntityType;
-  const hostEntityBundle = element.dataset.hostEntityBundle;
-  const hostEntityUuid = element.dataset.hostEntityUuid;
-  const dropAlignment = element.dataset.fieldDropAlignment;
-  const cardinality = Number.parseInt(element.dataset.fieldCardinality || "-1");
-  const allowedBundles = (element.dataset.fieldAllowedBundles || "").split(",").filter(Boolean);
-  const allowedFragments = (element.dataset.allowedFragments || "").split(",").filter(Boolean);
-  if (key && name && label && hostEntityType && hostEntityUuid && hostEntityBundle && fieldListType) {
-    return {
-      key,
-      name,
-      label,
-      isNested,
-      nestingLevel,
-      hostEntityType,
-      hostEntityUuid,
-      hostEntityBundle,
-      cardinality: Number.isNaN(cardinality) ? -1 : cardinality,
-      allowedBundles,
-      allowedFragments,
-      fieldListType,
-      element,
-      dropAlignment: dropAlignment === "vertical" || dropAlignment === "horizontal" ? dropAlignment : void 0
-    };
-  }
-};
-function rectWithTime(rect, time) {
-  return {
-    ...rect,
-    time: time || performance.now()
-  };
-}
-export default function(ui, debug, definitions) {
-  const logger = debug.createLogger("DomProvider");
-  const mutationsReady = ref(true);
-  const intersectionReady = ref(false);
-  const visibleBlocks = /* @__PURE__ */ new Set();
-  const visibleFields = /* @__PURE__ */ new Set();
-  const blockRects = {};
-  const fieldRects = {};
-  const blockUuidCurrentKey = {};
-  let draggableBlockCache = {};
-  const resizeObserver = new ResizeObserver(function(entries) {
-    for (const entry of entries) {
-      if (!(entry.target instanceof HTMLElement)) {
-        return;
-      }
-      const uuid = entry.target.dataset.uuid || entry.target.closest("[data-uuid]")?.dataset.uuid;
-      if (!uuid) {
-        return;
-      }
-      const currentRect = blockRects[uuid];
-      const now = performance.now();
-      if (!currentRect) {
-        blockRects[uuid] = rectWithTime(
-          {
-            x: entry.contentRect.x,
-            y: entry.contentRect.y,
-            width: entry.borderBoxSize[0].inlineSize,
-            height: entry.borderBoxSize[0].blockSize
-          },
-          now
-        );
-        return;
-      }
-      if (currentRect.time > now) {
-        return;
-      }
-      blockRects[uuid].width = entry.borderBoxSize[0].inlineSize;
-      blockRects[uuid].height = entry.borderBoxSize[0].blockSize;
-      blockRects[uuid].time = now;
-    }
-  });
-  function intersectionCallback(entries) {
-    const scale = ui.artboardScale.value;
-    const offset = ui.artboardOffset.value;
-    for (const entry of entries) {
-      if (entry.target instanceof HTMLElement) {
-        const uuid = entry.target.dataset.uuid || entry.target.closest("[data-uuid]")?.dataset.uuid;
-        const fieldKey = entry.target.dataset.fieldKey;
-        const rect = entry.target.getBoundingClientRect();
-        if (fieldKey) {
-          if (entry.isIntersecting) {
-            visibleFields.add(fieldKey);
-          } else {
-            visibleFields.delete(fieldKey);
-          }
-          fieldRects[fieldKey] = ui.getAbsoluteElementRect(rect, scale, offset);
-        } else if (uuid) {
-          const newRect = ui.getAbsoluteElementRect(rect, scale, offset);
-          const currentRect = blockRects[uuid];
-          if (currentRect) {
-            if (currentRect.time > entry.time) {
-              blockRects[uuid].x = newRect.x;
-              blockRects[uuid].y = newRect.y;
-            } else {
-              blockRects[uuid] = rectWithTime(newRect, entry.time);
-            }
-          } else {
-            blockRects[uuid] = rectWithTime(newRect, entry.time);
-          }
-          if (entry.isIntersecting) {
-            visibleBlocks.add(uuid);
-          } else {
-            visibleBlocks.delete(uuid);
-          }
-        }
-      }
-    }
-  }
-  const intersectionObserver = useDelayedIntersectionObserver(intersectionCallback);
-  const registeredBlocks = reactive({});
-  const registeredFields = reactive({});
-  const registeredFieldTypes = computed(() => {
-    const fields = Object.values(registeredFields);
-    const found = /* @__PURE__ */ new Set();
-    const uniqueFieldTypes = [];
-    for (let i = 0; i < fields.length; i++) {
-      const field = fields[i];
-      if (field) {
-        const key = `${field.entity.type}:${field.entity.bundle}:${field.fieldName}`;
-        if (!found.has(key)) {
-          uniqueFieldTypes.push({
-            entityType: field.entity.type,
-            entityBundle: field.entity.bundle,
-            fieldName: field.fieldName
-          });
-          found.add(key);
-        }
-      }
-    }
-    return uniqueFieldTypes;
-  });
-  const registerField = (entity, fieldName, element) => {
-    const key = `${entity.uuid}:${fieldName}`;
-    registeredFields[key] = { element, entity, fieldName };
-    intersectionObserver.observe(element);
-  };
-  const updateFieldElement = (entity, fieldName, element) => {
-    const key = `${entity.uuid}:${fieldName}`;
-    const existingElement = registeredFields[key]?.element;
-    if (existingElement) {
-      intersectionObserver.unobserve(existingElement);
-    }
-    registeredFields[key] = { entity, fieldName, element };
-    intersectionObserver.observe(element);
-  };
-  const unregisterField = (entity, fieldName) => {
-    const key = `${entity.uuid}:${fieldName}`;
-    const el = registeredFields[key]?.element;
-    if (el) {
-      intersectionObserver.unobserve(el);
-    }
-    visibleFields.delete(key);
-    registeredFields[key] = void 0;
-  };
-  function getElementToObserve(el, bundle, fieldListType, parentBlockBundle) {
-    if (el.classList.contains("bk-block-proxy")) {
-      return el;
-    }
-    const definition = definitions.getBlockDefinition(
-      bundle,
-      fieldListType,
-      parentBlockBundle
-    );
-    if (!definition) {
-      throw new Error("Failed to load definition for bundle: " + bundle);
-    }
-    const observableElement = (definition.editor?.getDraggableElement ? definition.editor.getDraggableElement(el) : el) || el;
-    if (observableElement instanceof HTMLElement) {
-      return observableElement;
-    }
-    return el;
-  }
-  const findBlock = (uuid) => {
-    const cached = draggableBlockCache[uuid];
-    if (cached) {
-      return cached;
-    }
-    const el = registeredBlocks[uuid];
-    if (!el) {
-      return;
-    }
-    const item = buildDraggableItem(el);
-    if (item?.itemType === "existing") {
-      draggableBlockCache[uuid] = item;
-      return item;
-    }
-  };
-  const getAllBlocks = () => {
-    return [
-      ...document.querySelectorAll(
-        '[data-blokkli-provider-active="true"] [data-uuid]'
-      )
-    ].map((v) => {
-      const item = buildDraggableItem(v);
-      if (item?.itemType === "existing") {
-        return item;
-      }
-    }).filter(falsy);
-  };
-  const getDropElementMarkup = (item, checkSize) => {
-    const el = item.itemType === "existing" ? getDragElement(item) : item.element();
-    if (!el) {
-      return "";
-    }
-    const dropElement = el.querySelector(".bk-drop-element") || el;
-    const childCount = dropElement.querySelectorAll("*").length;
-    if (checkSize && childCount > 80) {
-      return "";
-    }
-    return cloneElementWithStyles(dropElement, true).replace(
-      /\sdata-\w+="[^"]*"/g,
-      ""
-    );
-  };
-  const findField = (uuid, fieldName) => {
-    const el = document.querySelector(
-      `[data-field-name="${fieldName}"][data-host-entity-uuid="${uuid}"]`
-    );
-    if (!(el instanceof HTMLElement)) {
-      return;
-    }
-    return buildFieldElement(el);
-  };
-  const getAllDroppableFields = () => [...document.querySelectorAll("[data-blokkli-droppable-field]")].filter((el) => {
-    return !el.closest('[data-bk-in-proxy="true"]');
-  }).map(mapDroppableField);
-  const getVisibleBlocks = () => Array.from(visibleBlocks);
-  const getVisibleFields = () => Array.from(visibleFields);
-  const getActiveProviderElement = () => {
-    const el = document.querySelector('[data-blokkli-provider-active="true"]');
-    if (!el) {
-      throw new Error("Failed to find active <BlokkliProvider> element.");
-    }
-    if (!(el instanceof HTMLElement)) {
-      throw new TypeError(
-        "The root element of the active <BlokkliProvider> is not an HTMLElement."
-      );
-    }
-    return el;
-  };
-  function getBlockRects() {
-    return blockRects;
-  }
-  function getBlockRect(uuid) {
-    return blockRects[uuid];
-  }
-  function getFieldRect(key) {
-    return fieldRects[key];
-  }
-  function refreshBlockRect(uuid) {
-    const block = findBlock(uuid);
-    if (!block) {
-      return;
-    }
-    const el = getDragElement(block);
-    if (!el) {
-      return;
-    }
-    blockRects[uuid] = rectWithTime(
-      ui.getAbsoluteElementRect(el.getBoundingClientRect())
-    );
-  }
-  function refreshFieldRect(key) {
-    const el = document.querySelector(
-      `.bk-draggable-list-container[data-field-key="${key}"]`
-    );
-    if (!(el instanceof HTMLElement)) {
-      return;
-    }
-    fieldRects[key] = ui.getAbsoluteElementRect(el.getBoundingClientRect());
-  }
-  let stateReloadTimeout = null;
-  function getUuidsToUpdateRectsFor() {
-    const allUuids = Object.keys(registeredBlocks);
-    if (allUuids.length < 150) {
-      return allUuids;
-    }
-    return getVisibleBlocks();
-  }
-  function updateVisibleRects() {
-    const toUpdate = getUuidsToUpdateRectsFor();
-    const offset = ui.artboardOffset.value;
-    const scale = ui.artboardScale.value;
-    for (let i = 0; i < toUpdate.length; i++) {
-      const uuid = toUpdate[i];
-      const el = registeredBlocks[uuid];
-      if (!el) {
-        continue;
-      }
-      const bundle = el.dataset.itemBundle;
-      const hostBundle = el.dataset.hostBundle;
-      const hostFieldListType = el.dataset.hostFieldListType;
-      if (!bundle || !hostFieldListType) {
-        continue;
-      }
-      const observableElement = getElementToObserve(
-        el,
-        bundle,
-        hostFieldListType,
-        hostBundle
-      );
-      blockRects[uuid] = rectWithTime(
-        ui.getAbsoluteElementRect(
-          observableElement.getBoundingClientRect(),
-          scale,
-          offset
-        )
-      );
-    }
-    const visibleFieldKeys = getVisibleFields();
-    for (let i = 0; i < visibleFieldKeys.length; i++) {
-      const key = visibleFieldKeys[i];
-      const field = registeredFields[key];
-      if (!field) {
-        continue;
-      }
-      fieldRects[key] = ui.getAbsoluteElementRect(
-        field.element.getBoundingClientRect(),
-        scale,
-        offset
-      );
-    }
-  }
-  onBlokkliEvent("state:reloaded", () => {
-    draggableBlockCache = {};
-    if (stateReloadTimeout) {
-      window.clearTimeout(stateReloadTimeout);
-    }
-    stateReloadTimeout = window.setTimeout(updateVisibleRects, 300);
-  });
-  onBlokkliEvent("ui:resized", function() {
-    updateVisibleRects();
-    getVisibleFields().forEach(refreshFieldRect);
-    logger.log("Refreshed all visible rects");
-  });
-  function init() {
-    intersectionObserver.init();
-    intersectionReady.value = true;
-    logger.log("IntersectionObserver initialized");
-  }
-  const dragElementUuidMap = /* @__PURE__ */ new WeakMap();
-  const dragElementCache = /* @__PURE__ */ new Map();
-  function getDragElement(block) {
-    const cached = dragElementCache.get(block.uuid);
-    if (cached && document.body.contains(cached)) {
-      return cached;
-    }
-    const el = block.element();
-    if (!el) {
-      return;
-    }
-    dragElementUuidMap.set(el, block.uuid);
-    dragElementCache.set(block.uuid, el);
-    return el;
-  }
-  function isBlockVisible(uuid) {
-    return visibleBlocks.has(uuid);
-  }
-  function registerBlock(key, uuid, el) {
-    logger.log("registerBlock: " + uuid);
-    blockUuidCurrentKey[uuid] = key;
-    if (!el) {
-      logger.log("registerBlock call unregisterBlock because no element", uuid);
-      unregisterBlock(key, uuid);
-      return;
-    }
-    if (registeredBlocks[uuid]) {
-      logger.log(
-        "registerBlock call unregisterBlock because already registered",
-        uuid
-      );
-      unregisterBlock(key, uuid);
-    }
-    const item = buildDraggableItem(el);
-    if (item && item.itemType === "existing") {
-      const observableElement = getElementToObserve(
-        el,
-        item.itemBundle,
-        item.hostFieldListType,
-        item.hostBundle
-      );
-      intersectionObserver.observe(observableElement);
-      resizeObserver.observe(observableElement);
-      registeredBlocks[item.uuid] = el;
-    }
-  }
-  function unregisterBlock(key, uuid) {
-    const currentKey = blockUuidCurrentKey[uuid];
-    if (currentKey && currentKey !== key) {
-      return;
-    }
-    logger.log("unregisterBlock: " + uuid);
-    const el = registeredBlocks[uuid];
-    if (el) {
-      intersectionObserver.unobserve(el);
-      resizeObserver.unobserve(el);
-      dragElementUuidMap.delete(el);
-      dragElementUuidMap.delete(el);
-    }
-    dragElementCache.delete(uuid);
-    registeredBlocks[uuid] = void 0;
-    delete blockRects[uuid];
-    visibleBlocks.delete(uuid);
-  }
-  return {
-    findBlock,
-    getAllBlocks,
-    findClosestBlock,
-    getDropElementMarkup,
-    findField,
-    getAllDroppableFields,
-    findClosestEntityContext,
-    getVisibleBlocks,
-    getVisibleFields,
-    registerField,
-    unregisterField,
-    updateFieldElement,
-    getActiveProviderElement,
-    getBlockRects,
-    getBlockRect,
-    getFieldRect,
-    refreshBlockRect,
-    isBlockVisible,
-    isReady: computed(() => mutationsReady.value && intersectionReady.value),
-    init,
-    getDragElement,
-    updateVisibleRects,
-    registeredFieldTypes,
-    registerBlock,
-    unregisterBlock
-  };
-}

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

@@ -1,9 +0,0 @@
-import type { DraggableItem, DropArea } from '#blokkli/types';
-type DropAreaProviderFunction = (items: DraggableItem[]) => DropArea[] | DropArea | undefined;
-export type DropAreaProvider = {
-    add: (fn: DropAreaProviderFunction) => void;
-    remove: (fn: DropAreaProviderFunction) => void;
-    getDropAreas: (items: DraggableItem[]) => DropArea[];
-};
-export default function (): DropAreaProvider;
-export {};

package/dist/runtime/helpers/dropAreaProvider.js

@@ -1,22 +0,0 @@
-import { falsy } from "./index.js";
-export default function() {
-  let functions = [];
-  const add = (fn) => {
-    functions.push(fn);
-  };
-  const remove = (fn) => {
-    functions = functions.filter((v) => v !== fn);
-  };
-  const getDropAreas = (items) => functions.flatMap((fn) => {
-    const v = fn(items);
-    if (v) {
-      return v;
-    }
-    return null;
-  }).filter(falsy);
-  return {
-    add,
-    remove,
-    getDropAreas
-  };
-}

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

@@ -1,3 +0,0 @@
-import type { EventbusEvents } from '#blokkli/types';
-export declare const eventBus: import("mitt").Emitter<EventbusEvents>;
-export declare const emitMessage: (message: string, type?: "success" | "error", additional?: string | Error | unknown) => void;

package/dist/runtime/helpers/eventBus.js

@@ -1,5 +0,0 @@
-import mitt from "mitt";
-export const eventBus = mitt();
-export const emitMessage = (message, type = "success", additional) => {
-  eventBus.emit("message", { type, message, additional });
-};

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

@@ -1,17 +0,0 @@
-import type { FeatureDefinition, AdapterMethods } from '#blokkli/types';
-import { type ValidFeatureKey } from '#blokkli-build/features';
-import { type ComputedRef } from '#imports';
-import type { StorageProvider } from './storageProvider.js';
-export type FeaturesProvider = {
-    features: ComputedRef<FeatureDefinition[]>;
-    mountedFeatures: ComputedRef<FeatureDefinition<AdapterMethods[], ValidFeatureKey>[]>;
-    betaFeatures: ComputedRef<{
-        id: ValidFeatureKey;
-        label: string;
-        description?: string;
-    }[]>;
-    enabledBetaFeatures: ComputedRef<ValidFeatureKey[]>;
-    mount: (feature: FeatureDefinition<AdapterMethods[], ValidFeatureKey>) => void;
-    unmount: (id: string) => void;
-};
-export default function (storage: StorageProvider): FeaturesProvider;

package/dist/runtime/helpers/featuresProvider.js

@@ -1,53 +0,0 @@
-import {
-  featureDefinitions
-} from "#blokkli-build/features";
-import { computed, ref } from "#imports";
-import { falsy } from "./index.js";
-export default function(storage) {
-  const definitions = ref(featureDefinitions);
-  const mountedFeatures = ref([]);
-  if (import.meta.hot) {
-    import.meta.hot.accept("#blokkli-build/features", (mod) => {
-      const newDefinitions = mod;
-      definitions.value = newDefinitions?.featureDefinitions || [];
-    });
-  }
-  const settingsSettings = storage.use(
-    "feature:settings:settings",
-    {}
-  );
-  const enabledBetaFeatures = computed(() => {
-    return Object.entries(settingsSettings.value).map(([key, value]) => {
-      const [a, b] = key.split(":");
-      if (a === "beta" && b && value === true) {
-        return b;
-      }
-      return null;
-    }).filter(falsy);
-  });
-  const betaFeatures = computed(
-    () => definitions.value.map((v) => {
-      if (v.beta && v.label) {
-        return {
-          id: v.id,
-          label: v.label,
-          description: v.description
-        };
-      }
-    }).filter(falsy)
-  );
-  const unmount = (id) => {
-    mountedFeatures.value = mountedFeatures.value.filter((v) => v.id !== id);
-  };
-  const mount = (feature) => {
-    mountedFeatures.value.push(feature);
-  };
-  return {
-    features: computed(() => definitions.value),
-    mountedFeatures: computed(() => mountedFeatures.value),
-    betaFeatures,
-    enabledBetaFeatures,
-    mount,
-    unmount
-  };
-}

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

@@ -1,9 +0,0 @@
-import type { MutatedField, UpdateBlockOptionEvent } from '../types/index.js';
-type FrameEventBusEvents = {
-    selectItems: string[];
-    mutatedFields: MutatedField[];
-    focus: string;
-    updateOption: UpdateBlockOptionEvent;
-};
-export declare const frameEventBus: import("mitt").Emitter<FrameEventBusEvents>;
-export {};

package/dist/runtime/helpers/frameEventBus.js

@@ -1,2 +0,0 @@
-import mitt from "mitt";
-export const frameEventBus = mitt();

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

@@ -1,18 +0,0 @@
-import { type Ref, type ComputedRef } from 'vue';
-import type { AnimationProvider } from './animationProvider.js';
-import type { KeyboardShortcut } from '#blokkli/types';
-type RegisteredShortcut = {
-    key: string;
-    shortcut: KeyboardShortcut;
-};
-export type KeyboardProvider = {
-    isPressingSpace: Readonly<Ref<boolean>>;
-    isPressingControl: Readonly<Ref<boolean>>;
-    isPressingShift: Readonly<Ref<boolean>>;
-    setShortcutStateFromEvent: (e: MouseEvent | PointerEvent) => void;
-    shortcuts: ComputedRef<RegisteredShortcut[]>;
-    registerShortcut: (shortcut: KeyboardShortcut) => void;
-    unregisterShortcut: (shortcut: KeyboardShortcut) => void;
-};
-export default function (animationProvider: AnimationProvider): KeyboardProvider;
-export {};