@lblod/ember-rdfa-editor-lblod-plugins 19.3.1 → 20.0.0

package/addon/plugins/structure-plugin/node.ts

@@ -0,0 +1,148 @@
+import type { ComponentLike } from '@glint/template';
+import { PNode, getRdfaAttrs, rdfaAttrSpec } from '@lblod/ember-rdfa-editor';
+import Structure from '@lblod/ember-rdfa-editor-lblod-plugins/components/structure-plugin/_private/structure';
+import { renderRdfaAware } from '@lblod/ember-rdfa-editor/core/schema';
+import {
+  createEmberNodeSpec,
+  createEmberNodeView,
+  EmberNodeConfig,
+} from '@lblod/ember-rdfa-editor/utils/ember-node';
+const rdfaAware = true;
+
+export const emberNodeConfig: () => EmberNodeConfig = () => {
+  return {
+    name: 'structure',
+    component: Structure as unknown as ComponentLike,
+    inline: false,
+    group: 'block structure',
+    content: 'block+',
+    draggable: false,
+    selectable: true,
+    isolating: true,
+    atom: false,
+    editable: rdfaAware,
+
+    attrs: {
+      ...rdfaAttrSpec({ rdfaAware }),
+
+      hasTitle: {
+        default: true,
+      },
+      title: {
+        default: 'title',
+      },
+      number: {
+        default: 1,
+      },
+      structureName: {
+        default: 'Structure',
+      },
+      headerTag: {
+        default: 'h3',
+      },
+
+      sayRenderAs: { default: 'structure' },
+    },
+    serialize(node: PNode) {
+      const parser = new DOMParser();
+      const tag = node.attrs.headerTag;
+      const structureName = node.attrs.structureName;
+      const number = node.attrs.number;
+
+      let headerSpec;
+      if (node.attrs.hasTitle) {
+        const html = parser.parseFromString(node.attrs.title, 'text/html');
+        if (html.body.firstElementChild) {
+          headerSpec = [
+            tag,
+            { 'data-say-structure-header': true },
+            [
+              'span',
+              { 'data-say-structure-header-name': true },
+              `${structureName} `,
+            ],
+            ['span', { 'data-say-structure-header-number': true }, number],
+            [
+              'span',
+              { 'data-say-structure-header-content': true },
+              html.body.firstElementChild,
+            ],
+          ];
+        } else {
+          headerSpec = [
+            tag,
+            [
+              'span',
+              { 'data-say-structure-header-name': true },
+              `${structureName} `,
+            ],
+            ['span', { 'data-say-structure-header-number': true }, number],
+          ];
+        }
+      } else {
+        headerSpec = [
+          tag,
+          [
+            'span',
+            { 'data-say-structure-header-name': true },
+            `${structureName} `,
+          ],
+          ['span', { 'data-say-structure-header-number': true }, number],
+        ];
+      }
+
+      return renderRdfaAware({
+        renderable: node,
+        tag: 'div',
+        attrs: {
+          'data-say-render-as': 'structure',
+          'data-say-has-title': node.attrs.hasTitle,
+          'data-say-structure-name': node.attrs.structureName,
+          'data-say-header-tag': node.attrs.headerTag,
+          'data-say-number': node.attrs.number,
+        },
+        content: [
+          'div',
+          headerSpec,
+          ['div', { 'data-say-structure-content': true }, 0],
+        ],
+      });
+    },
+    parseDOM: [
+      {
+        tag: 'div',
+        getAttrs(node: string | HTMLElement) {
+          if (typeof node === 'string') {
+            return false;
+          }
+          const attrs = getRdfaAttrs(node, { rdfaAware });
+          if (node.dataset.sayRenderAs === 'structure') {
+            const hasTitle =
+              node.dataset.sayHasTitle && node.dataset.sayHasTitle !== 'false';
+            // strict selector here to avoid false positives when structures are nested
+            // :scope refers to the element on which we call querySelector
+            const titleElement = node.querySelector(
+              ':scope > div > div > [data-say-structure-header] > [data-say-structure-header-content]',
+            );
+            let title: string | undefined = undefined;
+            if (titleElement) {
+              title = titleElement.innerHTML;
+            }
+            return {
+              ...attrs,
+              hasTitle,
+              structureName: node.dataset.sayStructureName,
+              headerTag: node.dataset.sayHeaderTag,
+              number: node.dataset.sayNumber,
+              title,
+            };
+          }
+          return false;
+        },
+        contentElement: `div[data-say-structure-content]`,
+      },
+    ],
+  };
+};
+export const structure = createEmberNodeSpec(emberNodeConfig());
+export const structureView = createEmberNodeView(emberNodeConfig());

package/addon/plugins/structure-plugin/recalculate-structure-numbers.ts

@@ -0,0 +1,28 @@
+import { EditorState } from '@lblod/ember-rdfa-editor';
+import {
+  BESLUIT,
+  RDF,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/utils/constants';
+import { hasOutgoingNamedNodeTriple } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/namespace';
+import type { TransactionMonadResult } from '@lblod/ember-rdfa-editor/utils/transaction-utils';
+
+export function recalculateNumbers(
+  state: EditorState,
+): TransactionMonadResult<boolean> {
+  const tr = state.tr;
+  const doc = tr.doc;
+  let counter = 0;
+  doc.descendants((node, pos) => {
+    if (
+      node.type.name === 'structure' &&
+      hasOutgoingNamedNodeTriple(node.attrs, RDF('type'), BESLUIT('Artikel'))
+    ) {
+      counter += 1;
+      if (counter !== Number(node.attrs.number)) {
+        tr.setNodeAttribute(pos, 'number', counter);
+      }
+    }
+    return true;
+  });
+  return { transaction: tr, result: true, initialState: state };
+}

package/addon/utils/find-insertion-pos-in-node.ts

@@ -0,0 +1,21 @@
+import { PNode, ResolvedPos } from '@lblod/ember-rdfa-editor';
+import { Option } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
+export function findInsertionPosInNode(
+  $searchPos: ResolvedPos,
+  $ancestorPos: ResolvedPos,
+  nodeToInsert: PNode,
+): Option<number> {
+  const ancestor = $ancestorPos.nodeAfter;
+
+  const insertionIndex = $searchPos.indexAfter($ancestorPos.depth);
+  const insertionPos = $searchPos.posAtIndex(
+    insertionIndex,
+    $ancestorPos.depth,
+  );
+  if (
+    !ancestor?.canReplaceWith(insertionIndex, insertionIndex, nodeToInsert.type)
+  ) {
+    return null;
+  }
+  return insertionPos;
+}

package/addon/utils/nested-prosemirror.ts

@@ -0,0 +1,111 @@
+import {
+  EditorState,
+  NodeSelection,
+  ProseParser,
+  SayController,
+  SayView,
+  Schema,
+  Transaction,
+  Selection,
+} from '@lblod/ember-rdfa-editor';
+import { htmlToDoc } from '@lblod/ember-rdfa-editor/utils/_private/html-utils';
+export interface NestedProsemirrorArgs {
+  target: HTMLElement;
+  schema: Schema;
+  outerView: SayView;
+  getPos: () => number | undefined;
+  controller: SayController;
+  onFocus: (view: SayView) => void;
+  onUpdateContent: (newContent: string) => void;
+  initialContent: string;
+}
+export default class NestedProsemirror {
+  view: SayView;
+  outerView: SayView;
+  getPos: () => number | undefined;
+  controller: SayController;
+  onFocus: (view: SayView) => void;
+  onUpdateContent: (newContent: string) => void;
+  constructor({
+    target,
+    schema,
+    outerView,
+    getPos,
+    controller,
+    onFocus,
+    onUpdateContent,
+    initialContent,
+  }: NestedProsemirrorArgs) {
+    const state = EditorState.create({ schema });
+    const parser = ProseParser.fromSchema(schema);
+    this.outerView = outerView;
+    this.getPos = getPos;
+    this.controller = controller;
+    this.onFocus = onFocus;
+    this.onUpdateContent = onUpdateContent;
+
+    this.view = new SayView(
+      { mount: target },
+      {
+        state,
+        domParser: parser,
+        dispatchTransaction: this.dispatch,
+        handleDOMEvents: {
+          mousedown: () => {
+            // Kludge to prevent issues due to the fact that the whole
+            // footnote is node-selected (and thus DOM-selected) when
+            // the parent editor is focused.
+
+            if (this.outerView.hasFocus()) this.view?.focus();
+          },
+          focus: () => {
+            const pos = this.getPos();
+            if (pos !== undefined) {
+              const outerSelectionTr = this.outerView.state.tr;
+              const outerSelection = new NodeSelection(
+                this.outerView.state.doc.resolve(pos),
+              );
+              outerSelectionTr.setSelection(outerSelection);
+              this.outerView.dispatch(outerSelectionTr);
+            }
+
+            if (this.view) {
+              this.controller.setActiveView(this.view);
+              this.onFocus?.(this.view);
+            }
+          },
+        },
+      },
+    );
+    if (initialContent) {
+      this.view.setHtmlContent(initialContent);
+    }
+  }
+
+  dispatch = (tr: Transaction) => {
+    if (this.view) {
+      const newState = this.view.state.apply(tr);
+      this.view.updateState(newState);
+      if (!tr.getMeta('fromOutside')) {
+        this.onUpdateContent(this.view.htmlContent);
+      }
+    }
+  };
+  setInnerHtmlContent(html: string) {
+    const state = this.view.state;
+    const tr = state.tr;
+    tr.setMeta('fromOutside', true);
+
+    const doc = htmlToDoc(html, {
+      schema: state.schema,
+      parser: this.view.domParser,
+      editorView: this.view,
+    });
+    tr.replaceWith(0, tr.doc.nodeSize - 2, doc);
+    tr.setSelection(Selection.atEnd(tr.doc));
+    this.dispatch(tr);
+  }
+  get htmlContent() {
+    return this.view.htmlContent;
+  }
+}

package/app/styles/structure-plugin.scss

@@ -0,0 +1,53 @@
+.say-structure {
+  border: 0.1rem solid var(--au-gray-300);
+  border-radius: var(--au-radius);
+
+  display: flex;
+  flex-direction: column;
+  white-space: normal;
+}
+.say-structure__header {
+  background-color: var(--au-gray-200);
+  display: flex;
+  gap: 5px;
+  flex-direction: row;
+  h4 {
+    margin: 0;
+  }
+  .say-structure__title {
+    flex-grow: 1;
+  }
+  [contenteditable] {
+    border: none;
+    font-size: var(--au-h4);
+    flex-grow: 1;
+    &:focus {
+      outline: none;
+    }
+    padding: 0;
+    white-space: break-spaces;
+    word-break: break-all;
+    word-wrap: break-word;
+  }
+  padding: var(--au-small);
+}
+.say-structure__content {
+  [data-slot] {
+    white-space: break-spaces;
+    word-break: break-all;
+    word-wrap: break-word;
+  }
+  padding: var(--au-small);
+}
+
+.say-structure__content.say-empty {
+  [data-ember-node-content] {
+    p::before {
+      color: var(--au-gray-400);
+      content: 'Fill in content...';
+      float: left;
+      height: 0;
+      pointer-events: none;
+    }
+  }
+}

package/declarations/addon/components/besluit-topic-plugin/besluit-topic-toolbar-dropdown.d.ts

@@ -18,10 +18,11 @@ export default class BesluitTopicToolbarDropdownComponent extends Component<Args
     cardExpanded: boolean;
     get controller(): SayController;
     get doc(): import("prosemirror-model").Node;
+    get decisionRange(): import("@lblod/ember-rdfa-editor/plugins/datastore").ElementPNode | undefined;
+    get showCard(): boolean;
     topics: import("ember-resources/util/function").State<Promise<BesluitTopic[]>>;
     findBesluitTopicsByUris(uris: string[], topics?: BesluitTopic[] | null): BesluitTopic[] | undefined;
     updateBesluitTopic(): void;
-    get showCard(): boolean;
     upsertBesluitTopic(selected: BesluitTopic[]): void;
     toggleCard(): void;
 }

package/declarations/addon/components/besluit-type-plugin/toolbar-dropdown.d.ts

@@ -1,6 +1,5 @@
 import Component from '@glimmer/component';
 import { SayController } from '@lblod/ember-rdfa-editor';
-import { ResolvedPNode } from '@lblod/ember-rdfa-editor/plugins/datastore';
 import { BesluitType } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/besluit-type-plugin/utils/fetchBesluitTypes';
 import { BesluitTypePluginOptions } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/besluit-type-plugin';
 type Args = {
@@ -28,7 +27,7 @@ export default class EditorPluginsToolbarDropdownComponent extends Component<Arg
     get controller(): SayController;
     get doc(): import("prosemirror-model").Node;
     types: import("ember-resources/util/function").State<Promise<BesluitType[]>>;
-    get currentBesluitRange(): ResolvedPNode | undefined;
+    get currentBesluitRange(): import("@lblod/ember-rdfa-editor/plugins/datastore").ElementPNode | undefined;
     get currentBesluitURI(): string | undefined;
     get showCard(): boolean;
     updateBesluitTypes(): void;

package/declarations/addon/components/decision-plugin/decision-plugin-card.d.ts

@@ -1,20 +1,29 @@
 import Component from '@glimmer/component';
-import { SayController } from '@lblod/ember-rdfa-editor';
+import type { SayController, Selection } from '@lblod/ember-rdfa-editor';
 import IntlService from 'ember-intl/services/intl';
-type Args = {
-    controller: SayController;
-};
-/**
- * @deprecated
- */
-export default class DecisionPluginCard extends Component<Args> {
-    AlertTriangleIcon: TOC<import("@appuniversum/ember-appuniversum/components/icons/alert-triangle").AlertTriangleIconSignature>;
+import { NodeWithPos } from '@curvenote/prosemirror-utils';
+interface DecisionCardOptions {
+    articleUriGenerator?: () => string;
+}
+interface Sig {
+    Args: {
+        controller: SayController;
+        options?: DecisionCardOptions;
+    };
+}
+export default class DecisionPluginCard extends Component<Sig> {
     intl: IntlService;
     get controller(): SayController;
+    get selection(): Selection;
+    get decisionNodeLocation(): NodeWithPos | null;
     focus(): void;
+    get canInsertTitle(): boolean | null;
+    insertTitle(): void;
+    get canInsertDescription(): boolean | null;
+    insertDescription(): void;
+    get canInsertMotivation(): boolean | null;
     insertMotivation(): void;
-    get canInsertMotivation(): boolean;
+    get missingArticleBlock(): boolean | null;
     insertArticleBlock(): void;
-    get missingArticleBlock(): boolean;
 }
 export {};

package/declarations/addon/components/decision-plugin/insert-article.d.ts

@@ -0,0 +1,23 @@
+import Component from '@glimmer/component';
+import { SayController } from '@lblod/ember-rdfa-editor';
+export interface InsertArticleOptions {
+    uriGenerator?: () => string;
+}
+interface Sig {
+    Args: {
+        controller: SayController;
+        options?: InsertArticleOptions;
+    };
+}
+export default class InsertArticleComponent extends Component<Sig> {
+    get controller(): SayController;
+    get schema(): import("prosemirror-model").Schema<any, any>;
+    get decisionRange(): import("@lblod/ember-rdfa-editor/plugins/datastore").ElementPNode | undefined;
+    get decisionLocation(): {
+        pos: number;
+        node: import("prosemirror-model").Node;
+    } | null;
+    get canInsert(): boolean;
+    doInsert(): void;
+}
+export {};

package/declarations/addon/components/hover-tooltip.d.ts

@@ -1,19 +1,36 @@
 import Component from '@glimmer/component';
+import { FunctionBasedModifier } from 'ember-modifier';
 import { Velcro } from 'ember-velcro';
-interface Args {
-    placement?: string;
+import { Signature as VelcroModifierSignature } from 'ember-velcro/modifiers/velcro';
+import { ModifierLike } from '@glint/template';
+export type Placement = VelcroModifierSignature['Args']['Named']['placement'];
+interface HoverModifierSig {
+    Element: HTMLElement;
 }
-export default class HoverTooltip extends Component<Args> {
-    Velcro: typeof Velcro;
-    hover: import("ember-modifier").FunctionBasedModifier<{
+interface Sig {
+    Args: {
+        placement?: Placement;
+    };
+    Blocks: {
+        hover: [
+            hover: {
+                velcroHook: ModifierLike<Velcro['velcroHook']>;
+                handleHover: ModifierLike<FunctionBasedModifier<HoverModifierSig>>;
+            }
+        ];
+        tooltip: [loop: ModifierLike<Velcro['velcroLoop']>];
+    };
+}
+export default class HoverTooltip extends Component<Sig> {
+    hover: FunctionBasedModifier<{
+        Element: HTMLElement;
         Args: {
-            Named: Record<string, unknown>;
-            Positional: unknown[];
+            Named: import("ember-modifier/-private/signature").EmptyObject;
+            Positional: [];
         };
-        Element: Element;
     }>;
     tooltipOpen: boolean;
-    get placement(): string;
+    get placement(): Placement | undefined;
     showTooltip: () => void;
     hideTooltip: () => void;
 }

package/declarations/addon/components/prosemirror-editor.d.ts

@@ -0,0 +1,23 @@
+import { SayController, SayView, Schema, Transaction } from '@lblod/ember-rdfa-editor';
+import Component from '@glimmer/component';
+type Args = {
+    onInit?(view: SayView): void;
+    onUpdate?(content: string): void;
+    onFocus?(view: SayView): void;
+    getPos(): number;
+    schema: Schema;
+    content?: string;
+    inline?: boolean;
+    controller: SayController;
+    outerView: SayView;
+};
+export default class ProseMirrorEditor extends Component<Args> {
+    view?: SayView;
+    initialContent: string;
+    constructor(owner: unknown, args: Args);
+    get outerView(): SayView;
+    handleInit(target: HTMLElement): void;
+    onContentUpdate(): void;
+    dispatch: (tr: Transaction) => void;
+}
+export {};

package/declarations/addon/components/roadsign-regulation-plugin/roadsigns-modal.d.ts

@@ -37,6 +37,12 @@ export default class RoadsignRegulationCard extends Component<Args> {
     get isNotTypeSign(): boolean;
     constructor(parent: unknown, args: Args);
     get schema(): import("prosemirror-model").Schema<any, any>;
+    get controller(): SayController;
+    get decisionRange(): import("@lblod/ember-rdfa-editor/plugins/datastore").ElementPNode | undefined;
+    get decisionLocation(): {
+        node: import("prosemirror-model").Node;
+        pos: number;
+    } | null;
     selectTypeOrCategory(option: Option): void;
     changeCode(value: Code): void;
     changeCodeCombination(value: Code[]): void;

package/declarations/addon/components/structure-plugin/_private/control-card.d.ts

@@ -0,0 +1,22 @@
+import { NodeWithPos } from '@curvenote/prosemirror-utils';
+import Component from '@glimmer/component';
+import { NodeType, SayController, Schema } from '@lblod/ember-rdfa-editor';
+import { Option } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
+interface Sig {
+    Args: {
+        controller: SayController;
+    };
+}
+export default class StructureControlCardComponent extends Component<Sig> {
+    get controller(): SayController;
+    get schema(): Schema;
+    get structureType(): NodeType | undefined;
+    get structure(): Option<NodeWithPos>;
+    get structureName(): string;
+    get canMoveUp(): boolean;
+    get canMoveDown(): boolean;
+    moveStructure(direction: 'down' | 'up'): void;
+    get canRemoveStructure(): boolean;
+    removeStructure(withContent: boolean): void;
+}
+export {};

package/declarations/addon/components/structure-plugin/_private/structure.d.ts

@@ -0,0 +1,32 @@
+import Component from '@glimmer/component';
+import { SayView, Schema } from '@lblod/ember-rdfa-editor';
+import NestedProsemirror from '@lblod/ember-rdfa-editor-lblod-plugins/utils/nested-prosemirror';
+import { EmberNodeArgs } from '@lblod/ember-rdfa-editor/utils/ember-node';
+interface Sig {
+    Args: EmberNodeArgs;
+    Blocks: {
+        default: [];
+    };
+}
+export default class Structure extends Component<Sig> {
+    titleSchema: Schema<"text" | "doc", "em" | "strong" | "redacted" | "underline" | "strikethrough" | "subscript" | "superscript" | "highlight" | "color">;
+    titleContent: any;
+    innerView?: SayView;
+    innerEditor: NestedProsemirror | null;
+    get showPlaceholder(): boolean;
+    get controller(): import("@lblod/ember-rdfa-editor").SayController;
+    get node(): import("prosemirror-model").Node;
+    get isEmpty(): boolean;
+    get tag(): string;
+    get titleAttr(): any;
+    get headerTag(): any;
+    get number(): any;
+    get structureName(): any;
+    get hasTitle(): any;
+    onAttrsUpdate(): void;
+    onTitleUpdate: (content: string) => void;
+    onInnerEditorFocus: (view: SayView) => void;
+    initializeNestedEditor(target: HTMLElement): void;
+    focusInner(): void;
+}
+export {};

package/declarations/addon/plugins/besluit-topic-plugin/utils/helpers.d.ts

@@ -1,4 +1,4 @@
 import { SayController } from '@lblod/ember-rdfa-editor';
-import { ResolvedPNode } from '@lblod/ember-rdfa-editor/plugins/datastore';
-export declare const getCurrentBesluitRange: (controller: SayController) => ResolvedPNode | undefined;
+import { ElementPNode } from '@lblod/ember-rdfa-editor/plugins/datastore';
+export declare const getCurrentBesluitRange: (controller: SayController) => ElementPNode | undefined;
 export declare const getCurrentBesluitURI: (controller: SayController) => string | undefined;

package/declarations/addon/plugins/decision-plugin/commands/insert-article-command.d.ts

@@ -0,0 +1,8 @@
+import { NodeWithPos } from '@curvenote/prosemirror-utils';
+import { Command, PNode } from '@lblod/ember-rdfa-editor';
+interface InsertArticleArgs {
+    node: PNode;
+    decisionLocation: NodeWithPos;
+}
+export default function insertArticle({ node, decisionLocation, }: InsertArticleArgs): Command;
+export {};

package/declarations/addon/plugins/decision-plugin/commands/insert-article-container.d.ts

@@ -1,8 +1,10 @@
 import { Command } from '@lblod/ember-rdfa-editor';
 import IntlService from 'ember-intl/services/intl';
+import { NodeWithPos } from '@curvenote/prosemirror-utils';
 interface InsertArticleContainerArgs {
     intl: IntlService;
-    validateShapes?: Set<string>;
+    decisionLocation: NodeWithPos;
+    articleUriGenerator?: () => string;
 }
-export default function insertArticleContainer({ intl, validateShapes, }: InsertArticleContainerArgs): Command;
+export default function insertArticleContainer({ decisionLocation, articleUriGenerator, }: InsertArticleContainerArgs): Command;
 export {};

package/declarations/addon/plugins/decision-plugin/commands/insert-description.d.ts

@@ -1,7 +1,8 @@
 import { EditorState, Transaction } from '@lblod/ember-rdfa-editor';
+import { NodeWithPos } from '@curvenote/prosemirror-utils';
 interface InsertDescriptionArgs {
     placeholderText: string;
-    validateShapes?: Set<string>;
+    decisionLocation: NodeWithPos;
 }
-export default function insertDescription({ placeholderText, validateShapes, }: InsertDescriptionArgs): (state: EditorState, dispatch?: ((tr: Transaction) => void) | undefined) => boolean;
+export default function insertDescription({ placeholderText, decisionLocation, }: InsertDescriptionArgs): (state: EditorState, dispatch?: ((tr: Transaction) => void) | undefined) => boolean;
 export {};

package/declarations/addon/plugins/decision-plugin/commands/insert-motivation.d.ts

@@ -1,8 +1,9 @@
 import { Command } from '@lblod/ember-rdfa-editor';
 import IntlService from 'ember-intl/services/intl';
+import { NodeWithPos } from '@curvenote/prosemirror-utils';
 interface InsertMotivationArgs {
     intl: IntlService;
-    validateShapes?: Set<string>;
+    decisionLocation: NodeWithPos;
 }
-export default function insertMotivation({ intl, validateShapes, }: InsertMotivationArgs): Command;
+export default function insertMotivation({ intl, decisionLocation, }: InsertMotivationArgs): Command;
 export {};

package/declarations/addon/plugins/decision-plugin/commands/insert-title.d.ts

@@ -1,7 +1,8 @@
 import { EditorState, Transaction } from '@lblod/ember-rdfa-editor';
+import { NodeWithPos } from '@curvenote/prosemirror-utils';
 interface InsertTitleArgs {
     placeholderText: string;
-    validateShapes?: Set<string>;
+    decisionLocation: NodeWithPos;
 }
-export default function insertTitle({ placeholderText, validateShapes, }: InsertTitleArgs): (state: EditorState, dispatch?: ((tr: Transaction) => void) | undefined) => boolean;
+export default function insertTitle({ placeholderText, decisionLocation, }: InsertTitleArgs): (state: EditorState, dispatch?: ((tr: Transaction) => void) | undefined) => boolean;
 export {};

package/declarations/addon/plugins/decision-plugin/utils/build-article-structure.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from '@lblod/ember-rdfa-editor';
+export declare function buildArticleStructure(schema: Schema, uriGenerator?: () => string): import("prosemirror-model").Node;