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

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

@@ -1,26 +1,26 @@
-import {
-  EditorState,
-  NodeSelection,
-  Transaction,
-} from '@lblod/ember-rdfa-editor';
-import { isNone } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
-import { transactionCompliesWithShapes } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/validation/utils/transaction-complies-with-shapes';
-import { findInsertionPosInAncestorOfType } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/find-insertion-pos-in-ancestor-of-type';
+import { EditorState, Transaction } from '@lblod/ember-rdfa-editor';
+import { NodeWithPos } from '@curvenote/prosemirror-utils';
+import { v4 as uuid } from 'uuid';
+import { addPropertyToNode } from '@lblod/ember-rdfa-editor/utils/rdfa-utils';
+import { ELI } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/constants';
+import { SayDataFactory } from '@lblod/ember-rdfa-editor/core/say-data-factory';
+import { transactionCombinator } from '@lblod/ember-rdfa-editor/utils/transaction-utils';
 
 interface InsertDescriptionArgs {
   placeholderText: string;
-  validateShapes?: Set<string>;
+  decisionLocation: NodeWithPos;
 }
 
 export default function insertDescription({
   placeholderText,
-  validateShapes,
+  decisionLocation,
 }: InsertDescriptionArgs) {
   return function (state: EditorState, dispatch?: (tr: Transaction) => void) {
-    const { selection, schema } = state;
+    const { schema } = state;
+    const descriptionId = uuid();
     const nodeToInsert = schema.node(
-      'description',
-      {},
+      'block_rdfa',
+      { rdfaNodeType: 'literal', __rdfaId: descriptionId },
       schema.node(
         'paragraph',
         null,
@@ -29,23 +29,26 @@ export default function insertDescription({
         }),
       ),
     );
-    const insertionPos = findInsertionPosInAncestorOfType(
-      selection,
-      schema.nodes.besluit,
-      nodeToInsert,
-    );
-    if (isNone(insertionPos)) {
-      return false;
-    }
     const tr = state.tr;
 
-    tr.replaceRangeWith(insertionPos, insertionPos, nodeToInsert);
-    if (!transactionCompliesWithShapes(state, tr, validateShapes)) {
-      return false;
-    }
-    if (dispatch) {
-      tr.setSelection(NodeSelection.create(tr.doc, insertionPos + 2));
-      dispatch(tr.scrollIntoView());
+    tr.replaceSelectionWith(nodeToInsert);
+
+    const factory = new SayDataFactory();
+    const { transaction: newTr, result } = transactionCombinator<boolean>(
+      state,
+      tr,
+    )([
+      addPropertyToNode({
+        resource: decisionLocation.node.attrs.subject,
+        property: {
+          predicate: ELI('description').full,
+          object: factory.literalNode(descriptionId),
+        },
+      }),
+    ]);
+    if (dispatch && result.every((ok) => ok)) {
+      // newTr.setSelection(NodeSelection.create(newTr.doc, insertionPos + 2));
+      dispatch(newTr.scrollIntoView());
     }
     return true;
   };

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

@@ -1,135 +1,135 @@
-import {
-  Command,
-  EditorState,
-  NodeSelection,
-  Transaction,
-} from '@lblod/ember-rdfa-editor';
-import { isNone } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
-import { transactionCompliesWithShapes } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/validation/utils/transaction-complies-with-shapes';
-import { findInsertionPosInAncestorOfType } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/find-insertion-pos-in-ancestor-of-type';
+import { Command, EditorState, Transaction } from '@lblod/ember-rdfa-editor';
 import IntlService from 'ember-intl/services/intl';
 import { getTranslationFunction } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/translation';
+import { BESLUIT } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/constants';
+import { NodeWithPos } from '@curvenote/prosemirror-utils';
+import { v4 as uuid } from 'uuid';
+import { addPropertyToNode } from '@lblod/ember-rdfa-editor/utils/_private/rdfa-utils';
+import { SayDataFactory } from '@lblod/ember-rdfa-editor/core/say-data-factory';
+import { transactionCombinator } from '@lblod/ember-rdfa-editor/utils/transaction-utils';
 
 interface InsertMotivationArgs {
   intl: IntlService;
-  validateShapes?: Set<string>;
+  decisionLocation: NodeWithPos;
 }
 
 export default function insertMotivation({
   intl,
-  validateShapes,
+  decisionLocation,
 }: InsertMotivationArgs): Command {
   return function (state: EditorState, dispatch?: (tr: Transaction) => void) {
     const translationWithDocLang = getTranslationFunction(state);
-    const { selection, schema } = state;
-    const nodeToInsert = schema.node('motivering', {}, [
-      schema.node(
-        'paragraph',
-        null,
-        schema.node('placeholder', {
-          placeholderText: translationWithDocLang(
-            'besluit-plugin.placeholder.government-body',
-            intl.t('besluit-plugin.placeholder.government-body'),
-          ),
-        }),
-      ),
-      schema.node(
-        'heading',
-        {
-          level: 5,
-        },
-        [schema.text(intl.t('besluit-plugin.text.authority'))],
-      ),
-      schema.node('bullet_list', null, [
-        schema.node('list_item', null, [
-          schema.node('paragraph', null, [
-            schema.node('placeholder', {
-              placeholderText: translationWithDocLang(
-                'besluit-plugin.placeholder.legal-jurisdiction',
-                intl.t('besluit-plugin.placeholder.legal-jurisdiction'),
-              ),
-            }),
+    const { schema } = state;
+    const decisionNode = decisionLocation;
+    const motivationId = uuid();
+    const nodeToInsert = schema.node(
+      'block_rdfa',
+      { rdfaNodeType: 'literal', __rdfaId: motivationId },
+      [
+        schema.node(
+          'paragraph',
+          null,
+          schema.node('placeholder', {
+            placeholderText: translationWithDocLang(
+              'besluit-plugin.placeholder.government-body',
+              intl.t('besluit-plugin.placeholder.government-body'),
+            ),
+          }),
+        ),
+        schema.node(
+          'heading',
+          {
+            level: 5,
+          },
+          [schema.text(intl.t('besluit-plugin.text.authority'))],
+        ),
+        schema.node('bullet_list', null, [
+          schema.node('list_item', null, [
+            schema.node('paragraph', null, [
+              schema.node('placeholder', {
+                placeholderText: translationWithDocLang(
+                  'besluit-plugin.placeholder.legal-jurisdiction',
+                  intl.t('besluit-plugin.placeholder.legal-jurisdiction'),
+                ),
+              }),
+            ]),
           ]),
         ]),
-      ]),
-      schema.node(
-        'heading',
-        {
-          level: 5,
-        },
-        [
-          schema.text(
-            translationWithDocLang(
-              'besluit-plugin.text.legal-context',
-              intl.t('besluit-plugin.text.legal-context'),
-            ),
-          ),
-        ],
-      ),
-      schema.node('bullet_list', null, [
-        schema.node('list_item', null, [
-          schema.node('paragraph', null, [
-            schema.node('placeholder', {
-              placeholderText: translationWithDocLang(
-                'besluit-plugin.placeholder.insert-legal-context',
-                intl.t('besluit-plugin.placeholder.insert-legal-context'),
+        schema.node(
+          'heading',
+          {
+            level: 5,
+          },
+          [
+            schema.text(
+              translationWithDocLang(
+                'besluit-plugin.text.legal-context',
+                intl.t('besluit-plugin.text.legal-context'),
               ),
-            }),
+            ),
+          ],
+        ),
+        schema.node('bullet_list', null, [
+          schema.node('list_item', null, [
+            schema.node('paragraph', null, [
+              schema.node('placeholder', {
+                placeholderText: translationWithDocLang(
+                  'besluit-plugin.placeholder.insert-legal-context',
+                  intl.t('besluit-plugin.placeholder.insert-legal-context'),
+                ),
+              }),
+            ]),
           ]),
         ]),
-      ]),
-      schema.node(
-        'heading',
-        {
-          level: 5,
-        },
-        [
-          schema.text(
-            translationWithDocLang(
-              'besluit-plugin.text.factual-context',
-              intl.t('besluit-plugin.text.factual-context'),
-            ),
-          ),
-        ],
-      ),
-      schema.node('bullet_list', null, [
-        schema.node('list_item', null, [
-          schema.node('paragraph', null, [
-            schema.node('placeholder', {
-              placeholderText: translationWithDocLang(
-                'besluit-plugin.placeholder.insert-factual-context',
-                intl.t('besluit-plugin.placeholder.insert-factual-context'),
+        schema.node(
+          'heading',
+          {
+            level: 5,
+          },
+          [
+            schema.text(
+              translationWithDocLang(
+                'besluit-plugin.text.factual-context',
+                intl.t('besluit-plugin.text.factual-context'),
               ),
-            }),
+            ),
+          ],
+        ),
+        schema.node('bullet_list', null, [
+          schema.node('list_item', null, [
+            schema.node('paragraph', null, [
+              schema.node('placeholder', {
+                placeholderText: translationWithDocLang(
+                  'besluit-plugin.placeholder.insert-factual-context',
+                  intl.t('besluit-plugin.placeholder.insert-factual-context'),
+                ),
+              }),
+            ]),
           ]),
         ]),
-      ]),
-    ]);
-    // how the offset between the insertion point and the point where the cursor should end up
-    const cursorOffset = 2;
-
-    const insertionPos = findInsertionPosInAncestorOfType(
-      selection,
-      schema.nodes.besluit,
-      nodeToInsert,
+      ],
     );
-    if (isNone(insertionPos)) {
-      return false;
-    }
     const tr = state.tr;
+    tr.replaceSelectionWith(nodeToInsert);
+    const factory = new SayDataFactory();
 
-    tr.replaceRangeWith(insertionPos, insertionPos, nodeToInsert);
-    if (!transactionCompliesWithShapes(state, tr, validateShapes)) {
+    const { transaction: newTr, result } = transactionCombinator<boolean>(
+      state,
+      tr,
+    )([
+      addPropertyToNode({
+        resource: decisionNode.node.attrs.subject,
+        property: {
+          predicate: BESLUIT('motivering').full,
+          object: factory.literalNode(motivationId),
+        },
+      }),
+    ]);
+    if (result.some((success) => !success)) {
       return false;
     }
     if (dispatch) {
-      const selectionPos = tr.doc.resolve(insertionPos + cursorOffset);
-      // const targetPos = tr.doc.resolve(insertionPos + cursorOffset + 1);
-      // TODO figure out why I cant just set a nodeSelection here
-      tr.setSelection(
-        new NodeSelection(tr.doc.resolve(selectionPos.posAtIndex(0))),
-      );
-      dispatch(tr);
+      dispatch(newTr);
     }
     return true;
   };

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

@@ -1,26 +1,26 @@
-import { isNone } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
-import {
-  EditorState,
-  NodeSelection,
-  Transaction,
-} from '@lblod/ember-rdfa-editor';
-import { transactionCompliesWithShapes } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/validation/utils/transaction-complies-with-shapes';
-import { findInsertionPosInAncestorOfType } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/find-insertion-pos-in-ancestor-of-type';
+import { EditorState, Transaction } from '@lblod/ember-rdfa-editor';
+import { NodeWithPos } from '@curvenote/prosemirror-utils';
+import { v4 as uuid } from 'uuid';
+import { addPropertyToNode } from '@lblod/ember-rdfa-editor/utils/rdfa-utils';
+import { ELI } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/constants';
+import { SayDataFactory } from '@lblod/ember-rdfa-editor/core/say-data-factory';
+import { transactionCombinator } from '@lblod/ember-rdfa-editor/utils/transaction-utils';
 
 interface InsertTitleArgs {
   placeholderText: string;
-  validateShapes?: Set<string>;
+  decisionLocation: NodeWithPos;
 }
 
 export default function insertTitle({
   placeholderText,
-  validateShapes,
+  decisionLocation,
 }: InsertTitleArgs) {
   return function (state: EditorState, dispatch?: (tr: Transaction) => void) {
-    const { selection, schema } = state;
+    const { schema } = state;
+    const titleId = uuid();
     const nodeToInsert = schema.node(
-      'besluit_title',
-      {},
+      'block_rdfa',
+      { rdfaNodeType: 'literal', __rdfaId: titleId },
       schema.node(
         'paragraph',
         null,
@@ -30,23 +30,25 @@ export default function insertTitle({
       ),
     );
 
-    const insertionPos = findInsertionPosInAncestorOfType(
-      selection,
-      schema.nodes.besluit,
-      nodeToInsert,
-    );
-    if (isNone(insertionPos)) {
-      return false;
-    }
     const tr = state.tr;
-    tr.replaceRangeWith(insertionPos, insertionPos, nodeToInsert);
+    tr.replaceSelectionWith(nodeToInsert);
 
-    if (!transactionCompliesWithShapes(state, tr, validateShapes)) {
-      return false;
-    }
-    if (dispatch) {
-      tr.setSelection(NodeSelection.create(tr.doc, insertionPos + 2));
-      dispatch(tr.scrollIntoView());
+    const factory = new SayDataFactory();
+    const { transaction: newTr, result } = transactionCombinator<boolean>(
+      state,
+      tr,
+    )([
+      addPropertyToNode({
+        resource: decisionLocation.node.attrs.subject,
+        property: {
+          predicate: ELI('title').full,
+          object: factory.literalNode(titleId),
+        },
+      }),
+    ]);
+    if (dispatch && result.every((ok) => ok)) {
+      // newTr.setSelection(NodeSelection.create(newTr.doc, insertionPos + 2));
+      dispatch(newTr.scrollIntoView());
     }
     return true;
   };

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

@@ -0,0 +1,44 @@
+import { Schema } from '@lblod/ember-rdfa-editor';
+import {
+  BESLUIT,
+  RDF,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/utils/constants';
+import { OutgoingTriple } from '@lblod/ember-rdfa-editor/core/rdfa-processor';
+import { SayDataFactory } from '@lblod/ember-rdfa-editor/core/say-data-factory';
+import { v4 as uuid } from 'uuid';
+
+export function buildArticleStructure(
+  schema: Schema,
+  uriGenerator?: () => string,
+) {
+  let articleResource: string;
+  if (uriGenerator) {
+    articleResource = uriGenerator();
+  } else {
+    const articleId = uuid();
+    articleResource = `http://data.lblod.info/artikels/--ref-uuid4-${articleId}`;
+  }
+  const factory = new SayDataFactory();
+  return schema.node(
+    'structure',
+    {
+      rdfaNodeType: 'resource',
+      properties: [
+        {
+          predicate: RDF('type').full,
+          object: factory.namedNode(BESLUIT('Artikel').full),
+        },
+      ] satisfies OutgoingTriple[],
+      hasTitle: true,
+      title: '',
+      structureName: 'Artikel',
+      headerTag: 'h5',
+      subject: articleResource,
+    },
+    schema.node(
+      'paragraph',
+      {},
+      schema.node('placeholder', { placeholderText: 'Voeg inhoud artikel in' }),
+    ),
+  );
+}

package/addon/plugins/roadsign-regulation-plugin/index.ts

@@ -1,4 +1,5 @@
 export type RoadsignRegulationPluginOptions = {
   endpoint: string;
   imageBaseUrl: string;
+  articleUriGenrator?: () => string;
 };

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

@@ -0,0 +1,120 @@
+import {
+  Command,
+  PNode,
+  ResolvedPos,
+  TextSelection,
+} from '@lblod/ember-rdfa-editor';
+import { findAncestorOfType } from '../article-structure-plugin/utils/structure';
+import {
+  findNodePosDown,
+  findNodePosUp,
+} from '@lblod/ember-rdfa-editor/utils/position-utils';
+import {
+  isNone,
+  unwrap,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
+import { recalculateNumbers } from './recalculate-structure-numbers';
+import { transactionCombinator } from '@lblod/ember-rdfa-editor/utils/transaction-utils';
+
+export function moveStructure(direction: 'up' | 'down'): Command {
+  return (state, dispatch) => {
+    const { doc, selection, schema } = state;
+    const structure = findAncestorOfType(selection, schema.nodes['structure']);
+    if (!structure) {
+      return false;
+    }
+    const { pos, node } = structure;
+    const currentPos = node.attrs['number'];
+    if (direction === 'up') {
+      if (currentPos <= 1) {
+        return false;
+      }
+      const previousStructurePos =
+        findNodePosUp(doc, pos, ($pos: ResolvedPos) => {
+          const node = $pos.nodeAfter;
+          if (node) {
+            return node.type.name === 'structure';
+          }
+          return false;
+        }).next().value ?? null;
+      if (isNone(previousStructurePos)) {
+        return false;
+      } else {
+        if (dispatch) {
+          const transaction = state.tr;
+          // we are moving the structure up, so if we delete it first, it won't affect the positions
+          // before it
+          transaction.delete(pos, pos + node.nodeSize);
+
+          // previousStructurePos is the position right BEFORE the previous structure,
+          // so inserting there is correct
+          transaction.insert(previousStructurePos, node);
+          // after updating we have to recalculate the numbers
+          const { transaction: newTr } = transactionCombinator(
+            state,
+            transaction,
+          )([recalculateNumbers]);
+
+          // previousStructurePos should now point to the position right before our moved structure
+          // so we can simply add 1 to get the first position inside of it, and for the end
+          // we add the nodesize and subtract one
+          newTr.setSelection(
+            TextSelection.create(
+              newTr.doc,
+              previousStructurePos + 1,
+              previousStructurePos + node.nodeSize - 1,
+            ),
+          );
+          dispatch(newTr);
+        }
+        return true;
+      }
+    } else {
+      // findNodePosUp and findNodePosDown have a different interface (historic reasons)
+      const nextStructureParentPos =
+        findNodePosDown(
+          doc,
+          doc.resolve(pos + node.nodeSize),
+          (parent: PNode) => {
+            return parent.type.name === 'structure';
+          },
+        ).next().value ?? null;
+      if (isNone(nextStructureParentPos)) {
+        return false;
+      }
+      // findNodePosDown has a weird quirk where it can only find positions IN nodes
+      // cause the filter function only receives the position's parent
+      // so we need to step back one here (or make a way more complicated filter)
+      const nextStructurePos = nextStructureParentPos - 1;
+      if (dispatch) {
+        const transaction = state.tr;
+        const $structurePos = doc.resolve(nextStructurePos);
+        const nextStructureNode = unwrap($structurePos.nodeAfter);
+
+        transaction.delete(pos, pos + node.nodeSize);
+        const insertPos = transaction.mapping.map(
+          nextStructurePos + nextStructureNode.nodeSize,
+        );
+        transaction.insert(insertPos, node);
+
+        const { transaction: newTr } = transactionCombinator(
+          state,
+          transaction,
+        )([recalculateNumbers]);
+
+        // since we've deleted something before the insert position, we have to map
+        // the positions through the transaction to find the moved node's new position
+        newTr.setSelection(
+          TextSelection.create(
+            newTr.doc,
+            insertPos + 1,
+            insertPos + node.nodeSize - 1,
+          ),
+        );
+        dispatch(newTr);
+      }
+
+      return true;
+    }
+  };
+}