@blokkli/editor 1.4.0-alpha.1 → 2.0.0-alpha.10

package/dist/runtime/adapter/index.d.ts

@@ -1,5 +1,5 @@
 import type { ComputedRef } from 'vue';
-import type { CommentItem, ConversionItem, MappedState, ImportItem, LibraryItem, BlockBundleDefinition, EntityTranslation, SearchContentItem, AddClipboardItemEvent, AddNewBlockEvent, AddReusableItemEvent, ImportFromExistingEvent, MakeReusableEvent, MoveMultipleBlocksEvent, MoveBlockEvent, UpdateBlockOptionEvent, AddContentSearchItemEvent, TransformPlugin, EditBlockEvent, PasteExistingBlocksEvent, UpdateFieldValueEvent, AssistantResult, DraggableHostData, DetachReusableBlockEvent, FieldConfig, EditableFieldConfig, DraggableMediaLibraryItem, DroppableFieldConfig } from './../types.js';
+import type { CommentItem, ConversionItem, MappedState, ImportItem, LibraryItem, BlockBundleDefinition, EntityTranslation, SearchContentItem, AddClipboardItemEvent, AddNewBlockEvent, AddReusableItemEvent, ImportFromExistingEvent, MakeReusableEvent, MoveMultipleBlocksEvent, MoveBlockEvent, UpdateBlockOptionEvent, AddContentSearchItemEvent, TransformPlugin, EditBlockEvent, PasteExistingBlocksEvent, UpdateFieldValueEvent, AssistantResult, DraggableHostData, DetachReusableBlockEvent, FieldConfig, EditableFieldConfig, DraggableMediaLibraryItem, DroppableFieldConfig, PublishOptions, GetEditStatesItem } from './../types/index.js';
 import type getVideoId from 'get-video-id';
 import type { GetMediaLibraryFunction } from './../components/Edit/Features/MediaLibrary/types.js';
 export type { GetMediaLibraryFunction };
@@ -121,12 +121,22 @@ export type BlokkliAdapterGetLibraryItemsData = {
     page: number;
     text: string;
 };
-export type BlokkliAdapterGetLibraryItemsResult = {
-    items: LibraryItem[];
+export type BlokkliAdapterSearchResults<T> = {
+    items: T[];
     total: number;
     perPage: number;
 };
+export type BlokkliAdapterGetLibraryItemsResult = BlokkliAdapterSearchResults<LibraryItem>;
+export type BlokkliAdapterGetEditStatesResult = BlokkliAdapterSearchResults<GetEditStatesItem>;
 export type BlokkliAdapterPublishOptions = {
+    /**
+     * The host entity type.
+     */
+    hostEntityType: string;
+    /**
+     * The host entity UUID.
+     */
+    hostEntityUuid: string;
     /**
      * Whether the editor will be closed after publishing.
      *
@@ -136,6 +146,14 @@ export type BlokkliAdapterPublishOptions = {
      * be closed anyway after publishing.
      */
     closeAfterPublish?: boolean;
+    /**
+     * If the host entity is currently unpublished, publish it.
+     */
+    publishIfUnpublished?: boolean;
+    /**
+     * The revision log message.
+     */
+    revisionLogMessage?: string;
 };
 export interface BlokkliAdapter<T> {
     /**
@@ -200,7 +218,7 @@ export interface BlokkliAdapter<T> {
     /**
      * Determine the block bundle for the given clipboard item.
      */
-    clipboardMapBundle?: (e: ClipboardMapBundleEvent) => string | undefined;
+    clipboardMapBundle?: (e: ClipboardMapBundleEvent) => string | undefined | null;
     /**
      * Add a clipboard item.
      */
@@ -276,6 +294,14 @@ export interface BlokkliAdapter<T> {
      * Resolve a comment.
      */
     resolveComment?: (uuid: string) => Promise<CommentItem[]>;
+    /**
+     * Get the publish options.
+     */
+    getPublishOptions?: () => Promise<PublishOptions>;
+    /**
+     * Search for edit states.
+     */
+    getEditStates?: (page?: number) => Promise<BlokkliAdapterGetEditStatesResult>;
     /**
      * Make an item reusable.
      */

package/dist/runtime/blokkliPlugins/AddAction/index.vue

@@ -16,72 +16,57 @@
   </Teleport>
 </template>
 
-<script lang="ts" setup>
-import { computed, useBlokkli, nextTick, ref } from '#imports'
-import type { BlokkliIcon } from '#blokkli-build/icons'
-import type { ActionPlacedEvent } from '#blokkli/types'
-import { AddListItem } from '#blokkli/components'
-import onBlokkliEvent from '#blokkli/helpers/composables/onBlokkliEvent'
-import defineTourItem from '#blokkli/helpers/composables/defineTourItem'
-
-const props = defineProps<{
-  type: string
-  title: string
-  icon: BlokkliIcon
-  itemBundle?: string
-  color: 'rose' | 'lime' | 'accent'
-  description?: string
-  disabled?: boolean
-  weight?: number
-}>()
-
-const item = ref<InstanceType<typeof AddListItem> | null>(null)
-
-const emit = defineEmits<{
-  (e: 'placed', data: ActionPlacedEvent): void
-}>()
-
-const { ui, state, features } = useBlokkli()
-
+<script setup>
+import { computed, useBlokkli, nextTick, ref } from "#imports";
+import { AddListItem } from "#blokkli/components";
+import onBlokkliEvent from "#blokkli/helpers/composables/onBlokkliEvent";
+import defineTourItem from "#blokkli/helpers/composables/defineTourItem";
+const props = defineProps({
+  type: { type: String, required: true },
+  title: { type: String, required: true },
+  icon: { type: null, required: true },
+  itemBundle: { type: String, required: false },
+  color: { type: String, required: true },
+  description: { type: String, required: false },
+  disabled: { type: Boolean, required: false },
+  weight: { type: Number, required: false }
+});
+const item = ref(null);
+const emit = defineEmits(["placed"]);
+const { ui, state, features } = useBlokkli();
 const addListAvailable = computed(
-  () => !!features.features.value.find((v) => v.id === 'add-list'),
-)
-
+  () => !!features.mountedFeatures.value.find((v) => v.id === "add-list")
+);
 const shouldRender = computed(
-  () => addListAvailable.value && state.editMode.value === 'editing',
-)
-
-const renderKey = ref('')
-
-onBlokkliEvent('add-list:change', () => {
+  () => addListAvailable.value && state.editMode.value === "editing"
+);
+const renderKey = ref("");
+onBlokkliEvent("add-list:change", () => {
   nextTick(() => {
-    renderKey.value = Math.round(Math.random() * 1000000000).toString()
-  })
-})
-
-onBlokkliEvent('action:placed', (e) => {
+    renderKey.value = Math.round(Math.random() * 1e9).toString();
+  });
+});
+onBlokkliEvent("action:placed", (e) => {
   if (e.action.actionType !== props.type) {
-    return
+    return;
   }
-
-  emit('placed', e)
-})
-
+  emit("placed", e);
+});
 defineTourItem(() => {
   if (!props.description) {
-    return
+    return;
   }
   return {
-    id: 'plugin:add_action:' + props.type,
+    id: "plugin:add_action:" + props.type,
     title: props.title,
     text: props.description,
-    element: () => item.value?.getElement(),
-  }
-})
+    element: () => item.value?.getElement()
+  };
+});
 </script>
 
-<script lang="ts">
+<script>
 export default {
-  name: 'PluginAddAction',
-}
+  name: "PluginAddAction"
+};
 </script>

package/dist/runtime/blokkliPlugins/AddAction/index.vue.d.ts

@@ -0,0 +1,26 @@
+import type { BlokkliIcon } from '#blokkli-build/icons';
+import type { ActionPlacedEvent } from '#blokkli/types';
+declare const _default: import("vue").DefineComponent<{
+    type: string;
+    title: string;
+    icon: BlokkliIcon;
+    itemBundle?: string;
+    color: "rose" | "lime" | "accent";
+    description?: string;
+    disabled?: boolean;
+    weight?: number;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    placed: (data: ActionPlacedEvent) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    type: string;
+    title: string;
+    icon: BlokkliIcon;
+    itemBundle?: string;
+    color: "rose" | "lime" | "accent";
+    description?: string;
+    disabled?: boolean;
+    weight?: number;
+}> & Readonly<{
+    onPlaced?: ((data: ActionPlacedEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/blokkliPlugins/ContextMenu/Menu/index.vue

@@ -12,84 +12,58 @@
   </div>
 </template>
 
-<script lang="ts" setup>
-import type { ContextMenu } from '#blokkli/types'
-import { Icon } from '#blokkli/components'
+<script setup>
+import { Icon } from "#blokkli/components";
 import {
   watch,
   ref,
   computed,
   onMounted,
   useBlokkli,
-  onBeforeUnmount,
-} from '#imports'
-import onBlokkliEvent from '#blokkli/helpers/composables/onBlokkliEvent'
-
-const props = defineProps<{
-  menu: ContextMenu[]
-  x: number
-  y: number
-}>()
-
-const emit = defineEmits(['close'])
-
-const { ui, selection } = useBlokkli()
-
-const rootEl = ref<HTMLDivElement | null>(null)
-
+  onBeforeUnmount
+} from "#imports";
+import onBlokkliEvent from "#blokkli/helpers/composables/onBlokkliEvent";
+const props = defineProps({
+  menu: { type: Array, required: true },
+  x: { type: Number, required: true },
+  y: { type: Number, required: true }
+});
+const emit = defineEmits(["close"]);
+const { ui, selection } = useBlokkli();
+const rootEl = ref(null);
 const innerStyle = computed(() => {
-  const horizontal =
-    props.x - 300 >
-    ui.visibleViewportPadded.value.x + ui.visibleViewportPadded.value.width
-      ? { right: 0 }
-      : { left: 0 }
-
-  const vertical =
-    props.y + 300 >
-    ui.visibleViewportPadded.value.y + ui.visibleViewportPadded.value.height
-      ? { bottom: 0 }
-      : { top: 0 }
-
+  const horizontal = props.x - 300 > ui.visibleViewportPadded.value.x + ui.visibleViewportPadded.value.width ? { right: 0 } : { left: 0 };
+  const vertical = props.y + 300 > ui.visibleViewportPadded.value.y + ui.visibleViewportPadded.value.height ? { bottom: 0 } : { top: 0 };
   return {
     ...horizontal,
-    ...vertical,
+    ...vertical
+  };
+});
+onBlokkliEvent("keyPressed", (e) => {
+  if (e.code === "Escape") {
+    emit("close");
   }
-})
-
-onBlokkliEvent('keyPressed', (e) => {
-  if (e.code === 'Escape') {
-    emit('close')
+});
+watch(selection.uuids, () => emit("close"));
+const onClick = (index) => {
+  const item = props.menu[index];
+  if (item && item.type === "button") {
+    item.callback();
   }
-})
-
-watch(selection.uuids, () => emit('close'))
-
-const onClick = (index: number) => {
-  const item = props.menu[index]
-  if (item && item.type === 'button') {
-    item.callback()
-  }
-  emit('close')
-}
-
-const onMouseDown = (e: MouseEvent) => {
+  emit("close");
+};
+const onMouseDown = (e) => {
   if (!rootEl.value) {
-    return
+    return;
   }
-
-  if (
-    (e.target instanceof HTMLElement || e.target instanceof SVGElement) &&
-    !e.target.contains(rootEl.value)
-  ) {
-    emit('close')
+  if ((e.target instanceof HTMLElement || e.target instanceof SVGElement) && !e.target.contains(rootEl.value)) {
+    emit("close");
   }
-}
-
+};
 onMounted(() => {
-  window.addEventListener('click', onMouseDown)
-})
-
+  window.addEventListener("click", onMouseDown);
+});
 onBeforeUnmount(() => {
-  window.removeEventListener('click', onMouseDown)
-})
+  window.removeEventListener("click", onMouseDown);
+});
 </script>

package/dist/runtime/blokkliPlugins/ContextMenu/Menu/index.vue.d.ts

@@ -0,0 +1,12 @@
+import type { ContextMenu } from '#blokkli/types';
+type __VLS_Props = {
+    menu: ContextMenu[];
+    x: number;
+    y: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/blokkliPlugins/ContextMenu/index.vue

@@ -15,35 +15,24 @@
   </Component>
 </template>
 
-<script lang="ts" setup>
-import type { ContextMenu } from '#blokkli/types'
-import { ref, computed, useBlokkli } from '#imports'
-import ContextMenuMenu from './Menu/index.vue'
-
-const props = withDefaults(
-  defineProps<{
-    id: string
-    menu: ContextMenu[]
-    tag?: string
-  }>(),
-  {
-    tag: 'div',
-  },
-)
-
-const { ui } = useBlokkli()
-
-const isVisible = computed(() => ui.openContextMenu.value === props.id)
-
-const x = ref(0)
-const y = ref(0)
-
-const onContextMenu = (e: MouseEvent) => {
-  if (!props.id || typeof props.id !== 'string' || !props.menu.length) {
-    return
+<script setup>
+import { ref, computed, useBlokkli } from "#imports";
+import ContextMenuMenu from "./Menu/index.vue";
+const props = defineProps({
+  id: { type: String, required: true },
+  menu: { type: Array, required: true },
+  tag: { type: String, required: false, default: "div" }
+});
+const { ui } = useBlokkli();
+const isVisible = computed(() => ui.openContextMenu.value === props.id);
+const x = ref(0);
+const y = ref(0);
+const onContextMenu = (e) => {
+  if (!props.id || typeof props.id !== "string" || !props.menu.length) {
+    return;
   }
-  x.value = e.clientX
-  y.value = e.clientY
-  ui.openContextMenu.value = props.id
-}
+  x.value = e.clientX;
+  y.value = e.clientY;
+  ui.openContextMenu.value = props.id;
+};
 </script>

package/dist/runtime/blokkliPlugins/ContextMenu/index.vue.d.ts

@@ -0,0 +1,20 @@
+import type { ContextMenu } from '#blokkli/types';
+type __VLS_Props = {
+    id: string;
+    menu: ContextMenu[];
+    tag?: string;
+};
+declare var __VLS_10: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_10) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    tag: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/blokkliPlugins/DebugOverlay/index.vue

@@ -4,31 +4,23 @@
   </Teleport>
 </template>
 
-<script lang="ts" setup>
-import { computed, onBeforeUnmount, onMounted, useBlokkli } from '#imports'
-
-const props = defineProps<{
-  id: string
-  title: string
-}>()
-
-const { debug } = useBlokkli()
-
+<script setup>
+import { computed, onBeforeUnmount, onMounted, useBlokkli } from "#imports";
+const props = defineProps({
+  id: { type: String, required: true },
+  title: { type: String, required: true }
+});
+const { debug } = useBlokkli();
 const isVisible = computed(
-  () =>
-    debug.isEnabled.value &&
-    debug.overlays.value.find((v) => v.id === props.id)?.active,
-)
-
+  () => debug.isEnabled.value && debug.overlays.value.find((v) => v.id === props.id)?.active
+);
 onMounted(() => {
-  debug.registerOverlay(props.id, props.title)
-})
-
+  debug.registerOverlay(props.id, props.title);
+});
 onBeforeUnmount(() => {
-  debug.unregisterOverlay(props.id)
-})
-
+  debug.unregisterOverlay(props.id);
+});
 defineOptions({
-  name: 'DebugOverlay',
-})
+  name: "DebugOverlay"
+});
 </script>

package/dist/runtime/blokkliPlugins/DebugOverlay/index.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    id: string;
+    title: string;
+};
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/blokkliPlugins/DroppableEdit/index.vue

@@ -11,7 +11,7 @@
         <slot />
         <template #footer>
           <button class="bk-button bk-is-primary" @click="onSubmit">
-            {{ $t('droppableEditFormSave', 'Save') }}
+            {{ $t("droppableEditFormSave", "Save") }}
           </button>
         </template>
       </FormOverlay>
@@ -19,55 +19,38 @@
   </Teleport>
 </template>
 
-<script setup lang="ts">
-import { FormOverlay } from '#blokkli/components'
-import onBlokkliEvent from '#blokkli/helpers/composables/onBlokkliEvent'
-import type { BlokkliIcon } from '#blokkli-build/icons'
-import type { DroppableEntityField, DroppableFieldConfig } from '#blokkli/types'
-import { ref, useBlokkli } from '#imports'
-
-const props = defineProps<{
-  id: string
-  title: string
-  icon: BlokkliIcon
-  entityType: string
-}>()
-
-const emit = defineEmits<{
-  (e: 'save', data: DroppableEntityField): void
-}>()
-
-const { $t, types, state } = useBlokkli()
-
-type DroppableField = {
-  field: DroppableEntityField
-  config: DroppableFieldConfig
-}
-
-const droppable = ref<DroppableField | null>(null)
-
-const isVisible = ref(false)
-
+<script setup>
+import { FormOverlay } from "#blokkli/components";
+import onBlokkliEvent from "#blokkli/helpers/composables/onBlokkliEvent";
+import { ref, useBlokkli } from "#imports";
+const props = defineProps({
+  id: { type: String, required: true },
+  title: { type: String, required: true },
+  icon: { type: null, required: true },
+  entityType: { type: String, required: true }
+});
+const emit = defineEmits(["save"]);
+const { $t, types, state } = useBlokkli();
+const droppable = ref(null);
+const isVisible = ref(false);
 const onClose = () => {
-  isVisible.value = false
-}
-
+  isVisible.value = false;
+};
 const onSubmit = () => {
   if (droppable.value) {
-    emit('save', droppable.value.field)
+    emit("save", droppable.value.field);
   }
-  isVisible.value = false
-  droppable.value = null
-}
-
-onBlokkliEvent('droppable:focus', (field) => {
-  if (state.editMode.value !== 'editing') {
-    return
+  isVisible.value = false;
+  droppable.value = null;
+};
+onBlokkliEvent("droppable:focus", (field) => {
+  if (state.editMode.value !== "editing") {
+    return;
   }
-  const config = types.getDroppableFieldConfig(field.fieldName, field.host)
+  const config = types.getDroppableFieldConfig(field.fieldName, field.host);
   if (config.allowedEntityType === props.entityType) {
-    isVisible.value = true
-    droppable.value = { field, config }
+    isVisible.value = true;
+    droppable.value = { field, config };
   }
-})
+});
 </script>

package/dist/runtime/blokkliPlugins/DroppableEdit/index.vue.d.ts

@@ -0,0 +1,24 @@
+import type { BlokkliIcon } from '#blokkli-build/icons';
+import type { DroppableEntityField } from '#blokkli/types';
+type __VLS_Props = {
+    id: string;
+    title: string;
+    icon: BlokkliIcon;
+    entityType: string;
+};
+declare var __VLS_18: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_18) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    save: (data: DroppableEntityField) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSave?: ((data: DroppableEntityField) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};