@blokkli/editor 2.0.0-alpha.23 → 2.0.0-alpha.25

package/dist/runtime/components/Edit/AddListItemIcon/index.vue

@@ -1,19 +0,0 @@
-<template>
-  <div
-    class="bk-list-item-icon"
-    :class="['bk-is-' + color, 'bk-is-' + orientation]"
-  >
-    <Icon v-if="icon" :name="icon" />
-    <ItemIcon v-else-if="bundle" :bundle="bundle" />
-  </div>
-</template>
-
-<script setup>
-import { ItemIcon, Icon } from "#blokkli/components";
-defineProps({
-  icon: { type: null, required: false, default: void 0 },
-  bundle: { type: String, required: false, default: void 0 },
-  color: { type: String, required: false, default: "default" },
-  orientation: { type: String, required: false, default: "horizontal" }
-});
-</script>

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

@@ -1,9 +0,0 @@
-import type { Command } from '#blokkli/types';
-type CommandsProviderFunction = () => Command[] | Command | undefined;
-export type CommandsProvider = {
-    add: (fn: CommandsProviderFunction) => void;
-    remove: (fn: CommandsProviderFunction) => void;
-    getCommands: () => Command[];
-};
-export default function (): CommandsProvider;
-export {};

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

@@ -1,33 +0,0 @@
-import type { StorageProvider } from './storageProvider.js';
-import { type ComputedRef } from '#imports';
-export type DebugLogger = {
-    log: (message: string, ...v: any) => void;
-    error: (message: string, ...v: any) => void;
-};
-export type LogMessage = {
-    type: 'log' | 'error' | 'event';
-    name: string;
-    date: string;
-    message: string;
-    context?: string;
-};
-type RegisteredDebugOverlay = {
-    id: string;
-    label: string;
-    active: boolean;
-};
-export type DebugProvider = {
-    isEnabled: ComputedRef<boolean>;
-    toggle: () => void;
-    createLogger: (name: string) => DebugLogger;
-    registerOverlay: (id: string, label: string) => void;
-    unregisterOverlay: (id: string) => void;
-    overlays: ComputedRef<RegisteredDebugOverlay[]>;
-    toggleOverlay: (id: string) => void;
-    registeredLoggers: ComputedRef<string[]>;
-    enabledLoggers: ComputedRef<string[]>;
-    toggleLogger: (name: string) => void;
-    getMessages: () => LogMessage[];
-};
-export default function (storage: StorageProvider): DebugProvider;
-export {};

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

@@ -1,19 +0,0 @@
-import { type Ref, type ComputedRef } from '#imports';
-import type { BlockDefinition, FragmentDefinition, ProviderDefinition } from '#blokkli-build/definitions';
-import type { ValidFieldListTypes, BlockBundleWithNested } from '#blokkli-build/generated-types';
-import type { DeepReadonly } from 'vue';
-import type { BlockDefinitionOptionsInput } from '../types/index.js';
-import { type RuntimeBlockOptionArray } from '#blokkli-build/runtime-options';
-export type DefinitionProvider = {
-    getBlockDefinition: (bundle: string, fieldListType: ValidFieldListTypes, parentBundle?: BlockBundleWithNested | null) => BlockDefinition | undefined;
-    getDefaultDefinition: (bundle: string) => BlockDefinition | undefined;
-    getFragmentDefinition: (name: string) => FragmentDefinition | undefined;
-    getProviderDefinition: (entityType: string, entityBundle: string) => ProviderDefinition | undefined;
-    getBlockIcon: (bundle: string) => string | undefined;
-    fragmentDefinitions: ComputedRef<FragmentDefinition[]>;
-    blockDefinitions: ComputedRef<BlockDefinition[]>;
-    globalOptions: DeepReadonly<Ref<BlockDefinitionOptionsInput>>;
-    runtimeOptions: DeepReadonly<Ref<Record<string, Record<string, RuntimeBlockOptionArray>>>>;
-    renderKey: DeepReadonly<Ref<string>>;
-};
-export default function (): DefinitionProvider;

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

@@ -1,90 +0,0 @@
-import { type ComputedRef } from '#imports';
-import type { DraggableExistingBlock, DraggableItem, EntityContext, Rectangle, RenderedFieldListItem, RegisteredField, RegisterFieldData } from '#blokkli/types';
-import type { UiProvider } from './uiProvider.js';
-import type { DebugProvider } from './debugProvider.js';
-import type { DefinitionProvider } from './definitionProvider.js';
-import type { StateProvider } from './stateProvider.js';
-import type { ElementProvider } from './providers/element.js';
-type RegisteredFieldType = {
-    entityType: string;
-    entityBundle: string;
-    fieldName: string;
-};
-type MeasuredBlockRect = Rectangle & {
-    time: number;
-};
-export type DomProvider = {
-    /**
-     * Return the droppable markup for a draggable item.
-     */
-    getDropElementMarkup(item: DraggableItem | RenderedFieldListItem, checkSize?: boolean): string;
-    registerBlock: (key: string, uuid: string, el: HTMLElement | null) => void;
-    unregisterBlock: (key: string, uuid: string) => void;
-    registerField: (entity: EntityContext, fieldName: string, instance: HTMLElement, data: RegisterFieldData) => void;
-    updateFieldElement: (entity: EntityContext, fieldName: string, element: HTMLElement, data: RegisterFieldData) => void;
-    unregisterField: (entity: EntityContext, fieldName: string) => void;
-    getRegisteredField: (uuid: string, fieldName: string) => RegisteredField | undefined;
-    registeredFieldTypes: ComputedRef<RegisteredFieldType[]>;
-    registeredBlockUuids: ComputedRef<string[]>;
-    getVisibleBlocks(): string[];
-    getVisibleFields(): string[];
-    isBlockVisible(uuid: string): boolean;
-    getBlockRects: () => Record<string, MeasuredBlockRect>;
-    getBlockRect: (uuid: string, refresh?: boolean) => MeasuredBlockRect | undefined;
-    refreshBlockRect: (uuid: string) => void;
-    getFieldRect: (key: string) => Rectangle | undefined;
-    registeredBlocks: ComputedRef<Record<string, HTMLElement | undefined>>;
-    updateVisibleRects: () => void;
-    isReady: ComputedRef<boolean>;
-    init: () => void;
-    /**
-     * Get the drag element for a block.
-     */
-    getDragElement: (block: DraggableExistingBlock | RenderedFieldListItem) => HTMLElement | undefined;
-    /**
-     * Get debug data for troubleshooting.
-     */
-    getDebugData: () => {
-        registeredBlocks: Array<{
-            uuid: string;
-            hasElement: boolean;
-            hasObservedElement: boolean;
-            hasRect: boolean;
-            hasCurrentKey: boolean;
-            isVisible: boolean;
-            elementInfo?: {
-                tagName: string;
-                bundle?: string;
-                hostBundle?: string;
-                fieldListType?: string;
-            };
-        }>;
-        fields: Array<{
-            key: string;
-            isVisible: boolean;
-            hasRect: boolean;
-            entityType: string;
-            entityBundle: string;
-            fieldName: string;
-        }>;
-        summary: {
-            totalRegisteredBlocks: number;
-            totalBlocksWithElements: number;
-            totalObservedElements: number;
-            totalBlockRects: number;
-            totalVisibleBlocks: number;
-            totalRegisteredFields: number;
-            totalVisibleFields: number;
-            totalFieldRects: number;
-            isInitializing: boolean;
-            isReady: boolean;
-        };
-        orphanedData: {
-            rectsWithoutRegistration: string[];
-            observedElementsWithoutRegistration: string[];
-            keysWithoutRegistration: string[];
-        };
-    };
-};
-export default function (ui: UiProvider, debug: DebugProvider, definitions: DefinitionProvider, state: StateProvider, element: ElementProvider): DomProvider;
-export {};

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/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/indicatorsProvider.d.ts

@@ -1,10 +0,0 @@
-import { type Ref } from 'vue';
-import type { BlockIndicator } from '../types/index.js';
-export type IndicatorsProvider = {
-    indicators: Ref<BlockIndicator[]>;
-    hovered: Ref<string>;
-    addIndicator: (indicator: BlockIndicator) => void;
-    removeIndicator: (id: string, uuid: string) => void;
-    setHovered: (uuid?: string | null) => void;
-};
-export default function (): IndicatorsProvider;

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

@@ -1,20 +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;
-    lockKeyboardEvents: (id: string) => void;
-    unlockKeyboardEvents: (id: string) => void;
-};
-export default function (animationProvider: AnimationProvider): KeyboardProvider;
-export {};

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

@@ -1,26 +0,0 @@
-import type { AddAction } from '#blokkli/types';
-import type { BlokkliIcon } from '#blokkli-build/icons';
-type PluginAddFunction<T> = () => T | T[] | undefined;
-type AddActionFunction = PluginAddFunction<AddAction>;
-export type ItemDropdownAction = {
-    id: string;
-    label: string;
-    description?: string;
-    enabled?: boolean;
-    icon?: BlokkliIcon;
-    bundle?: string;
-    weight?: number;
-    group: string;
-    callback: () => void;
-};
-type ItemDropdownActionFunction = PluginAddFunction<ItemDropdownAction>;
-export type PluginProvider = {
-    addAddAction: (fn: AddActionFunction) => void;
-    removeAddAction: (fn: AddActionFunction) => void;
-    getAddActions: () => AddAction[];
-    addItemDropdownAction: (fn: ItemDropdownActionFunction) => void;
-    removeItemDropdownAction: (fn: ItemDropdownActionFunction) => void;
-    getItemDropdownActions: () => ItemDropdownAction[];
-};
-export default function (): PluginProvider;
-export {};

package/dist/runtime/helpers/pluginProvider.js

@@ -1,62 +0,0 @@
-export default function() {
-  let addActions = [];
-  let itemDropdownActions = [];
-  function addAddAction(fn) {
-    addActions.push(fn);
-  }
-  function removeAddAction(fn) {
-    addActions = addActions.filter((v) => v !== fn);
-  }
-  function getAddActions() {
-    const actions = [];
-    for (let i = 0; i < addActions.length; i++) {
-      const callback = addActions[i];
-      if (!callback) {
-        continue;
-      }
-      const result = callback();
-      if (!result) {
-        continue;
-      }
-      if (Array.isArray(result)) {
-        actions.push(...result);
-      } else {
-        actions.push(result);
-      }
-    }
-    return actions;
-  }
-  function addItemDropdownAction(fn) {
-    itemDropdownActions.push(fn);
-  }
-  function removeItemDropdownAction(fn) {
-    itemDropdownActions = itemDropdownActions.filter((v) => v !== fn);
-  }
-  function getItemDropdownActions() {
-    const actions = [];
-    for (let i = 0; i < itemDropdownActions.length; i++) {
-      const callback = itemDropdownActions[i];
-      if (!callback) {
-        continue;
-      }
-      const result = callback();
-      if (!result) {
-        continue;
-      }
-      if (Array.isArray(result)) {
-        actions.push(...result);
-      } else {
-        actions.push(result);
-      }
-    }
-    return actions;
-  }
-  return {
-    addAddAction,
-    removeAddAction,
-    getAddActions,
-    addItemDropdownAction,
-    removeItemDropdownAction,
-    getItemDropdownActions
-  };
-}

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

@@ -1,47 +0,0 @@
-import { type Ref, type ComputedRef } from 'vue';
-import type { BlokkliAdapter, AdapterContext } from '../adapter/index.js';
-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;
-    currentUserIsOwner: boolean;
-};
-export type RenderedBlock = {
-    item: FieldListItem;
-    parentEntityType: string;
-    parentEntityBundle: string;
-    parentEntityUuid: string;
-};
-export type StateProvider = {
-    owner: Readonly<Ref<BlokkliOwner | null>>;
-    refreshKey: Readonly<Ref<string>>;
-    mutatedFields: Readonly<Ref<MutatedField[]>>;
-    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[]>>;
-    mutateWithLoadingState: MutateWithLoadingStateFunction;
-    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, providerKey: string, permissions: EditPermission[]): Promise<StateProvider>;

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

@@ -1,17 +0,0 @@
-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, persist?: boolean) => WritableComputedRef<T>;
-    useWithContextPrefix: <T>(key: string, defaultValue: T, persist?: boolean) => WritableComputedRef<T>;
-    clearAll: () => void;
-    clear: (key: string) => void;
-};
-/**
- * Create a reactive variable that is synced to local storage using the
- * given key. The sync only happens client side and after the component
- * has been mounted.
- *
- * This composable can be used to keep state across page navigations and
- * even after a refresh.
- */
-export default function (adapter: BlokkliAdapter<any>, context: ComputedRef<AdapterContext>): Promise<StorageProvider>;

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

@@ -1,30 +0,0 @@
-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>;
-    teal: Ref<ThemeContextColors>;
-    yellow: Ref<ThemeContextColors>;
-    red: Ref<ThemeContextColors>;
-    lime: Ref<ThemeContextColors>;
-    orange: Ref<ThemeContextColors>;
-};
-export type ThemeProvider = {
-    accent: Ref<ThemeColors>;
-    mono: Ref<ThemeColors>;
-    teal: Ref<ThemeContextColors>;
-    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;
-    invalidateCachedStyle: (el: HTMLElement | SVGElement) => void;
-    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 (element: ElementProvider): ThemeProvider;
-export {};

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

@@ -1,11 +0,0 @@
-import type { TourItem } from '#blokkli/types';
-import { type Ref } from '#imports';
-type TourProviderFunction = () => TourItem[] | TourItem | undefined;
-export type TourProvider = {
-    add: (fn: TourProviderFunction) => void;
-    remove: (fn: TourProviderFunction) => void;
-    getTourItems: () => TourItem[];
-    isTouring: Ref<boolean>;
-};
-export default function (): TourProvider;
-export {};

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

@@ -1,36 +0,0 @@
-import type { ComputedRef } from 'vue';
-import type { FieldConfig, BlockBundleDefinition, EditableFieldConfig, BlockDefinitionInput, BlockDefinitionOptionsInput, DroppableFieldConfig, DraggableExistingBlock, EntityContext } from '../types/index.js';
-import type { AdapterContext, BlokkliAdapter } from '../adapter/index.js';
-import type { SelectionProvider } from './selectionProvider.js';
-export type BlokkliBlockType = BlockBundleDefinition & {
-    definition: BlockDefinitionInput<BlockDefinitionOptionsInput, never[]> | undefined;
-};
-interface MappableConfig {
-    entityType: string;
-    entityBundle: string;
-    name: string;
-}
-declare class ConfigMap<T extends MappableConfig> {
-    private configs;
-    private mapEntityType;
-    private mapEntityTypeBundle;
-    private mapEntityTypeBundleName;
-    constructor(items: T[]);
-    forEntityType(entityType: string): T[];
-    forEntityTypeAndBundle(entityType: string, entityBundle: string): T[];
-    forName(entityType: string, entityBundle: string, name: string): T | undefined;
-    all(): T[];
-}
-export type BlockDefinitionProvider = {
-    itemBundlesWithNested: string[];
-    allowedTypesInList: ComputedRef<string[]>;
-    generallyAvailableBundles: BlockBundleDefinition[];
-    getBlockBundleDefinition: (bundle: string) => BlockBundleDefinition | undefined;
-    getFieldConfig: (entityType: string, entityBundle: string, fieldName: string) => FieldConfig | undefined;
-    fieldConfig: ConfigMap<FieldConfig>;
-    editableFieldConfig: ConfigMap<EditableFieldConfig>;
-    droppableFieldConfig: ConfigMap<DroppableFieldConfig>;
-    getDroppableFieldConfig: (fieldName: string, host: DraggableExistingBlock | EntityContext) => DroppableFieldConfig;
-};
-export default function (adapter: BlokkliAdapter<any>, selection: SelectionProvider, context: ComputedRef<AdapterContext>): Promise<BlockDefinitionProvider>;
-export {};

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

@@ -1,60 +0,0 @@
-import { type Ref, type ComputedRef } from 'vue';
-import type { StorageProvider } from './storageProvider.js';
-import type { AddListOrientation, Coord, Rectangle, SidebarRegion, Size } from '#blokkli/types';
-import type { Viewport } from '#blokkli/constants';
-import type { StateProvider } from './stateProvider.js';
-import type { AdapterContext } from '#blokkli/adapter';
-import type { ThemeColorName } from '#blokkli/types/theme';
-import type { ElementProvider } from './providers/element.js';
-export type UiProvider = {
-    rootElement: () => HTMLElement;
-    artboardElement: () => HTMLElement;
-    providerElement: HTMLElement;
-    menu: {
-        isOpen: Readonly<Ref<boolean>>;
-        close: () => void;
-        open: () => void;
-    };
-    isMobile: ComputedRef<boolean>;
-    isDesktop: ComputedRef<boolean>;
-    isAnimating: Ref<boolean>;
-    isAnalyzing: Ref<boolean>;
-    isProxyMode: Ref<boolean>;
-    hasDialogOpen: Ref<boolean>;
-    hasTooltipOpen: ComputedRef<boolean>;
-    openTooltip: Ref<string>;
-    selectionColor: ComputedRef<ThemeColorName | null>;
-    setSelectionColor: (id: string, color: ThemeColorName) => void;
-    removeSelectionColor: (id: string) => void;
-    hasTransformOverlayOpen: Ref<boolean>;
-    isTransforming: ComputedRef<boolean>;
-    setTransform: (label?: string | null | undefined) => void;
-    transformLabel: ComputedRef<string>;
-    useAnimations: ComputedRef<boolean>;
-    lowPerformanceMode: ComputedRef<boolean>;
-    toolbarHeight: ComputedRef<number>;
-    visibleViewport: ComputedRef<Rectangle>;
-    visibleViewportPadded: ComputedRef<Rectangle>;
-    addListOrientation: ComputedRef<AddListOrientation>;
-    setViewportBlockingRectangle: (key: string, rect?: Rectangle) => void;
-    viewportBlockingRects: ComputedRef<Rectangle[]>;
-    appViewport: ComputedRef<Viewport>;
-    openContextMenu: Ref<string>;
-    viewport: ComputedRef<Size>;
-    artboardSize: ComputedRef<Size>;
-    artboardScale: Ref<number>;
-    artboardOffset: Ref<Coord>;
-    selectionTopLeft: Ref<Coord>;
-    interfaceLanguage: ComputedRef<string>;
-    locale: ComputedRef<string>;
-    formatDate: (date: string | Date, options?: Intl.DateTimeFormatOptions) => string;
-    getAbsoluteElementRect: (v: HTMLElement | Rectangle, scale?: number, offset?: Coord) => Rectangle;
-    getViewportRelativeRect: (rect: Rectangle, scale?: number, offset?: Coord) => Rectangle;
-    setBannerHeight: (id: string, height: number) => void;
-    removeBanner: (id: string) => void;
-    setActiveSidebar: (region: SidebarRegion, id: string) => void;
-    removeActiveSidebar: (region: SidebarRegion, id: string) => void;
-    hasSidebarLeft: ComputedRef<boolean>;
-    hasSidebarRight: ComputedRef<boolean>;
-};
-export default function (providerElement: HTMLElement, storage: StorageProvider, state: StateProvider, context: ComputedRef<AdapterContext>, element: ElementProvider): UiProvider;

package/dist/runtime/types/blokkOptions.d.ts

@@ -1,100 +0,0 @@
-import type { BlokkliIcon } from '#blokkli-build/icons';
-type DefinitionOptionText = {
-    type: 'text';
-    default: string;
-    label: string;
-    description?: string;
-    inputType?: 'text' | 'number' | 'date';
-    group?: string;
-};
-type DefinitionOptionNumber = {
-    type: 'number';
-    default: number;
-    label: string;
-    description?: string;
-    min: number;
-    max: number;
-    group?: string;
-};
-type DefinitionOptionRange = {
-    type: 'range';
-    default: number;
-    label: string;
-    description?: string;
-    min: number;
-    max: number;
-    step: number;
-    group?: string;
-};
-type DefinitionOptionDateTimeLocal = {
-    type: 'datetime-local';
-    label: string;
-    description?: string;
-    default?: string;
-    min?: string;
-    max?: string;
-    group?: string;
-};
-type DefinitionOptionCheckbox = {
-    type: 'checkbox';
-    default: boolean;
-    label: string;
-    description?: string;
-    group?: string;
-};
-type DefinitionOptionColor = {
-    type: 'color';
-    default: `#${string}`;
-    label: string;
-    description?: string;
-    group?: string;
-};
-type DefinitionOptionCheckboxes = {
-    type: 'checkboxes';
-    label: string;
-    description?: string;
-    /**
-     * The default values.
-     */
-    default: string[];
-    options: Record<string, string>;
-    group?: string;
-};
-type DefinitionOptionRadiosGridOption = {
-    columns: number[];
-    label: string;
-};
-type DefinitionOptionRadiosGrid = {
-    displayAs: 'grid';
-    options: Record<string, DefinitionOptionRadiosGridOption>;
-};
-type DefinitionOptionRadiosColorsOption = {
-    hex?: `#${string}`;
-    class?: string;
-    label: string;
-};
-type DefinitionOptionRadiosColors = {
-    displayAs: 'colors';
-    options: Record<string, DefinitionOptionRadiosColorsOption>;
-};
-type DefinitionOptionRadiosRadios = {
-    displayAs?: 'radios' | undefined;
-    options: Record<string, string>;
-};
-type DefinitionOptionRadiosIconsOption = {
-    icon: BlokkliIcon;
-    label: string;
-};
-type DefinitionOptionRadiosIcons = {
-    displayAs: 'icons';
-    options: Record<string, DefinitionOptionRadiosIconsOption>;
-};
-type DefinitionOptionRadios = {
-    type: 'radios';
-    label: string;
-    description?: string;
-    default: string;
-    group?: string;
-} & (DefinitionOptionRadiosColors | DefinitionOptionRadiosGrid | DefinitionOptionRadiosRadios | DefinitionOptionRadiosIcons);
-export type BlockOptionDefinition = DefinitionOptionColor | DefinitionOptionCheckbox | DefinitionOptionCheckboxes | DefinitionOptionRadios | DefinitionOptionText | DefinitionOptionRange | DefinitionOptionNumber | DefinitionOptionDateTimeLocal;
-export {};