@lblod/ember-rdfa-editor-lblod-plugins 0.4.1 → 1.0.0-alpha.1

package/CHANGELOG.md

@@ -7,6 +7,31 @@
 
 
 
+
+## 1.0.0-alpha.1 (2022-12-22)
+
+#### :rocket: Enhancement
+* [#35](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/35) converting the besluit-plugin to new API ([@usrtim](https://github.com/usrtim))
+* [#34](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/34) Add and convert citation plugin ([@abeforgit](https://github.com/abeforgit))
+* [#32](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/32) Convert table-of-contents plugin to prosemirror based editor. ([@elpoelma](https://github.com/elpoelma))
+* [#33](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/33) feature/dev utils ([@abeforgit](https://github.com/abeforgit))
+* [#31](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/31) Convert roadsign-regulation plugin to prosemirror based editor. ([@elpoelma](https://github.com/elpoelma))
+* [#28](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/28) Convert insert-variable plugin to prosemirror based editor. ([@elpoelma](https://github.com/elpoelma))
+* [#29](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/29) Convert template-variable plugin to prosemirror based editor. ([@elpoelma](https://github.com/elpoelma))
+* [#20](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/20) Convert standard-template plugin to prosemirror based editor plugin ([@elpoelma](https://github.com/elpoelma))
+* [#19](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/19) Convert import-snippet plugin to prosemirror based editor plugin ([@elpoelma](https://github.com/elpoelma))
+* [#18](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/18) Convert besluit-type plugin to prosemirror based editor plugin ([@elpoelma](https://github.com/elpoelma))
+* [#17](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/17) Convert rdfa-date plugin to prosemirror based editor plugin ([@elpoelma](https://github.com/elpoelma))
+
+#### :house: Internal
+* [#26](https://github.com/lblod/ember-rdfa-editor-lblod-plugins/pull/26) Convert besluit-type, import-snippet, rdfa-date and standard-template plugins to typescript ([@elpoelma](https://github.com/elpoelma))
+
+#### Committers: 4
+- Arne Bertrand ([@abeforgit](https://github.com/abeforgit))
+- Elena Poelman ([@elpoelma](https://github.com/elpoelma))
+- Oscar Rodriguez Villalobos ([@lagartoverde](https://github.com/lagartoverde))
+- [@usrtim](https://github.com/usrtim)
+
 ## 0.4.1 (2022-12-02)
 
 #### :bug: Bug Fix

package/addon/commands/article-structure-plugin/delete-structure.ts

@@ -0,0 +1,85 @@
+import { ProseController } from '@lblod/ember-rdfa-editor';
+import { ResolvedArticleStructurePluginOptions } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/article-structure-plugin';
+import { unwrap } from '@lblod/ember-rdfa-editor/utils/option';
+import { Command } from 'prosemirror-state';
+import recalculateStructureNumbers from './recalculate-structure-numbers';
+
+export default function deleteStructure(
+  controller: ProseController,
+  uri: string,
+  options: ResolvedArticleStructurePluginOptions
+): Command {
+  return (state, dispatch) => {
+    if (dispatch) {
+      const structureToDeleteRange = [
+        ...controller.datastore.match(`>${uri}`).asSubjectNodeMapping().nodes(),
+      ][0];
+      const structureToDeleteTypes = [
+        ...controller.datastore
+          .match(`>${uri}`, 'a')
+          .asQuadResultSet()
+          .map((quad) => quad.object.value),
+      ];
+      if (!structureToDeleteRange) {
+        throw new Error(`No node found for resource ${uri}`);
+      }
+      if (!structureToDeleteTypes) {
+        throw new Error(`No type found for resource ${uri}`);
+      }
+
+      const resolvedPos = state.doc.resolve(structureToDeleteRange.from);
+      const container = resolvedPos.parent;
+      let containerRange = {
+        from: resolvedPos.before(),
+        to: resolvedPos.before() + container.nodeSize,
+      };
+      const tr = state.tr;
+      if (container.childCount === 1) {
+        const placeholder = controller.schema.node('placeholder', {
+          placeholderText: 'Voer inhoud in',
+        });
+        tr.replaceRangeWith(
+          structureToDeleteRange.from,
+          structureToDeleteRange.to,
+          placeholder
+        );
+      } else {
+        tr.delete(structureToDeleteRange.from, structureToDeleteRange.to);
+      }
+      dispatch(tr);
+      containerRange = {
+        from: tr.mapping.map(containerRange.from),
+        to: tr.mapping.map(containerRange.to),
+      };
+      const currentStructureIndex = options.structures.findIndex((structure) =>
+        structureToDeleteTypes.includes(structure.type)
+      );
+      const currentStructure = unwrap(
+        options.structures[currentStructureIndex]
+      );
+      controller.doCommand(
+        recalculateStructureNumbers(
+          controller,
+          containerRange,
+          currentStructure,
+          options
+        )
+      );
+      recalculateContinuousStructures(controller, options);
+    }
+    return true;
+  };
+}
+
+function recalculateContinuousStructures(
+  controller: ProseController,
+  options: ResolvedArticleStructurePluginOptions
+) {
+  for (const structure of options.structures) {
+    if (structure.numbering === 'continuous') {
+      controller.doCommand(
+        recalculateStructureNumbers(controller, null, structure, options)
+      );
+    }
+  }
+}

package/addon/commands/article-structure-plugin/index.ts

@@ -0,0 +1,4 @@
+export { default as deleteStructure } from './delete-structure';
+export { default as insertArticleStructure } from './insert-article-structure';
+export { default as moveStructure } from './move-structure';
+export { default as recalculateStructureNumbers } from './recalculate-structure-numbers';

package/addon/commands/article-structure-plugin/insert-article-structure.ts

@@ -0,0 +1,137 @@
+import { v4 as uuid } from 'uuid';
+import { ProseController, TextSelection } from '@lblod/ember-rdfa-editor';
+import IntlService from 'ember-intl/services/intl';
+import { Command } from 'prosemirror-state';
+import { unwrap } from '@lblod/ember-rdfa-editor/utils/option';
+import ValidationReport from 'rdf-validate-shacl/src/validation-report';
+import { findNodes } from '@lblod/ember-rdfa-editor/utils/position-utils';
+import { insertHtml } from '@lblod/ember-rdfa-editor/commands/insert-html-command';
+import recalculateStructureNumbers from './recalculate-structure-numbers';
+import { ResolvedArticleStructurePluginOptions } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/article-structure-plugin';
+import { getRdfaAttribute } from '@lblod/ember-rdfa-editor/utils/rdfa-utils';
+
+export default function insertArticleStructureV2(
+  controller: ProseController,
+  structureName: string,
+  options: ResolvedArticleStructurePluginOptions,
+  report: ValidationReport,
+  intlService: IntlService
+): Command {
+  return (_state, dispatch) => {
+    const structureTypeToAdd = options.structures.find(
+      (structure) => structure.title === structureName
+    );
+    if (!structureTypeToAdd) {
+      console.warn(`Structure type ${structureName} not recognized`);
+      return false;
+    }
+    const structureUri = `${structureTypeToAdd.uriBase}${uuid()}`;
+    const urisNotAllowedToInsert = report.results.map(
+      (result) => result.focusNode?.value
+    );
+    const { selection } = controller.state;
+    const filterFunction = ({ from }: { from: number }) => {
+      const node = unwrap(controller.state.doc.nodeAt(from));
+      const nodeUri = getRdfaAttribute(node, 'resource').pop();
+      if (nodeUri && !urisNotAllowedToInsert.includes(nodeUri)) {
+        return true;
+      }
+      return false;
+    };
+
+    let structureContainerRange =
+      findNodes(
+        controller.state.doc,
+        selection.from,
+        true,
+        false,
+        filterFunction
+      ).next().value ??
+      findNodes(
+        controller.state.doc,
+        selection.from,
+        true,
+        true,
+        filterFunction
+      ).next().value;
+
+    if (!structureContainerRange) return false;
+    const structureContainerNode = unwrap(
+      controller.state.doc.nodeAt(structureContainerRange.from)
+    );
+    if (structureTypeToAdd.insertPredicate) {
+      const structureContainerUri = getRdfaAttribute(
+        structureContainerNode,
+        'resource'
+      ).pop();
+      if (!structureContainerUri) {
+        return false;
+      }
+      structureContainerRange = [
+        ...controller.datastore
+          .match(
+            `>${structureContainerUri}`,
+            `>${structureTypeToAdd.insertPredicate.long}`
+          )
+          .asPredicateNodeMapping()
+          .nodes(),
+      ][0];
+    }
+    if (!structureContainerRange) {
+      return false;
+    }
+    if (dispatch) {
+      const structureHtml = structureTypeToAdd.template(
+        structureUri,
+        intlService
+      );
+
+      //Detect if structureContainer only contains a placeholder, if so replace the full content of the structureContainer
+      let insertRange: { from: number; to: number };
+      if (
+        structureContainerNode.childCount === 1 &&
+        structureContainerNode.child(0).childCount === 1 &&
+        structureContainerNode.child(0).child(0).type ===
+          controller.schema.nodes['placeholder']
+      ) {
+        insertRange = {
+          from: structureContainerRange.from + 1,
+          to: structureContainerRange.to - 1,
+        };
+      } else {
+        insertRange = {
+          from: structureContainerRange.to - 1,
+          to: structureContainerRange.to - 1,
+        };
+      }
+      controller.doCommand(
+        insertHtml(structureHtml, insertRange.from, insertRange.to)
+      );
+      const containerNode = unwrap(
+        controller.state.doc.nodeAt(structureContainerRange.from)
+      );
+      const containerRange = {
+        from: structureContainerRange.from,
+        to: structureContainerRange.from + containerNode.nodeSize,
+      };
+
+      controller.doCommand(
+        recalculateStructureNumbers(
+          controller,
+          containerRange,
+          structureTypeToAdd,
+          options
+        )
+      );
+
+      const selection = TextSelection.near(
+        controller.state.doc.resolve(insertRange.from)
+      );
+      controller.withTransaction((tr) => {
+        return tr.setSelection(selection);
+      });
+      controller.focus();
+    }
+    return true;
+  };
+}

package/addon/commands/article-structure-plugin/move-structure.ts

@@ -0,0 +1,227 @@
+/* eslint-disable prettier/prettier */
+import {
+  ProseController,
+  TextSelection,
+} from '@lblod/ember-rdfa-editor';
+import { Command } from 'prosemirror-state';
+import ValidationReport from 'rdf-validate-shacl/src/validation-report';
+import {
+  findChildren,
+  findNodes,
+} from '@lblod/ember-rdfa-editor/utils/position-utils';
+import recalculateStructureNumbers from './recalculate-structure-numbers';
+import { unwrap } from '@lblod/ember-rdfa-editor/utils/option';
+import { ResolvedArticleStructurePluginOptions } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/article-structure-plugin';
+import { getRdfaAttribute } from '@lblod/ember-rdfa-editor/utils/rdfa-utils';
+export default function moveStructure(
+  controller: ProseController,
+  structureURI: string,
+  moveUp: boolean,
+  options: ResolvedArticleStructurePluginOptions,
+  report: ValidationReport
+): Command {
+  return (state, dispatch) => {
+    const structureRange = controller.datastore
+      .match(`>${structureURI}`)
+      .asSubjectNodeMapping()
+      .single()?.nodes[0];
+    if (!structureRange) {
+      console.warn(`Structure with URI ${structureURI} not found, cancelling move command`);
+      return false;
+    }
+
+    const resolvedStructurePos = state.doc.resolve(structureRange?.from);
+    const structureContainer = resolvedStructurePos.parent;
+    let structureContainerRange = { from: resolvedStructurePos.before(), to: resolvedStructurePos.before() + structureContainer.nodeSize};
+    const structures = [
+      ...findChildren(
+        controller.state.doc,
+        structureContainerRange.from,
+        false,
+        false,
+        ({ from }) => !controller.state.doc.nodeAt(from)?.isText
+      ),
+    ];
+    const structureIndex = structures.findIndex(
+      (structure) => structure.from === structureRange.from && structure.to === structureRange.to
+    );
+
+    // The type of the structure we want to move
+    const currentStructureType = controller.datastore
+      .match(`>${structureURI}`, 'a')
+      .asQuadResultSet()
+      .first()?.object.value;
+
+    // The spec describing the structure we want to move
+    const currentStructureSpec = options.structures.find(
+      (structureSpec) => structureSpec.type === currentStructureType
+    );
+    if(!currentStructureSpec){
+      return false;
+    }
+    if (
+      ((structureIndex !== 0 && moveUp) ||
+        (structureIndex !== structures.length - 1 && !moveUp)) &&
+      structures.length > 1
+    ) {
+      if (dispatch) {
+        let structureARange: { from: number, to: number };
+        let structureBRange: { from: number, to: number };
+        if (moveUp) {
+          structureARange = unwrap(structures[structureIndex - 1]);
+          structureBRange = unwrap(structures[structureIndex]);
+        } else {
+          structureARange = unwrap(structures[structureIndex]);
+          structureBRange = unwrap(structures[structureIndex + 1]);
+        }
+        const structureBNode = unwrap(controller.state.doc.nodeAt(structureBRange.from));
+        controller.withTransaction((tr) => {
+          tr.delete(structureBRange.from, structureBRange.to);
+          return tr.replaceRangeWith(structureARange.from, structureARange.from, structureBNode);
+        });
+        const structureContainer = unwrap(
+          controller.state.doc.nodeAt(structureContainerRange.from)
+        );
+        structureContainerRange = {
+          from: structureContainerRange.from,
+          to: structureContainerRange.from + structureContainer.nodeSize,
+        };
+        controller.doCommand(
+          recalculateStructureNumbers(
+            controller,
+            structureContainerRange,
+            currentStructureSpec,
+            options
+          )
+        );
+        recalculateContinuousStructures(controller, options);
+
+        // We place our resulting selection in the title of the structure
+        const headingRange = unwrap([
+          ...controller.datastore
+            .match(`>${structureURI}`, 'ext:title')
+            .asPredicateNodeMapping()
+            .nodes(),
+        ][0]);
+        const newSelection = TextSelection.near(
+          controller.state.doc.resolve(headingRange.to)
+        );
+        controller.withTransaction((tr) => {
+          return tr.setSelection(newSelection);
+        });
+        controller.focus();
+      }
+
+      return true;
+    } else {
+      const urisNotAllowedToInsert = report.results.map(
+        (result) => result.focusNode?.value
+      );
+      const structureContainerURI = (getRdfaAttribute(structureContainer, 'resource').pop()) ?? (getRdfaAttribute(resolvedStructurePos.node(resolvedStructurePos.depth - 1), 'resource').pop());
+      const filterFunction = ({ from }: { from: number }) => {
+        const node = unwrap(controller.state.doc.nodeAt(from));
+        const nodeUri = getRdfaAttribute(node, 'resource').pop();
+        if(structureContainerURI === nodeUri) {
+          return false;
+        }
+        return !!nodeUri && !urisNotAllowedToInsert.includes(nodeUri);
+      };
+      // The new structure container we want to move our structure in to.
+      let newStructureContainerRange: { from: number, to: number } | void = findNodes(
+        controller.state.doc,
+        structureRange.from,
+        true,
+        moveUp,
+        filterFunction
+      ).next().value;
+      if (!newStructureContainerRange) {
+        return false;
+      }
+      const newStructureContainerNode = unwrap(controller.state.doc.nodeAt(newStructureContainerRange.from));
+
+      const newStructureContainerURI = getRdfaAttribute(newStructureContainerNode, 'resource').pop();
+      // Check if there is a specific predicate container we need to insert inside
+      if (currentStructureSpec.insertPredicate) {
+        newStructureContainerRange = findChildren(controller.state.doc, newStructureContainerRange.from, false, false, ({ from }) => getRdfaAttribute(unwrap(controller.state.doc.nodeAt(from)), 'property').pop() === currentStructureSpec.insertPredicate?.short).next().value;
+      }
+      if(!newStructureContainerRange){
+        return false;
+      }
+      if(dispatch){
+        let insertRange: {from: number, to: number};
+
+        // Check if the newStructureContainer we want to insert to only contains a placeholder
+        if (
+          newStructureContainerNode.childCount === 1 &&
+          newStructureContainerNode.child(0).childCount === 1 &&
+          newStructureContainerNode.child(0).child(0).type ===
+          controller.schema.nodes['placeholder']
+        ) {
+          insertRange = {from: newStructureContainerRange.from + 1, to: newStructureContainerRange.to - 1};
+        } else {
+          insertRange = {from: newStructureContainerRange.to - 1, to: newStructureContainerRange.to - 1};
+        }
+        const structureNode = unwrap(controller.state.doc.nodeAt(structureRange.from));
+        controller.withTransaction((tr) => {
+          tr.replaceRangeWith(insertRange.from, insertRange.to, structureNode);
+          const oldStructureRange = { from: tr.mapping.map(structureRange.from), to: tr.mapping.map(structureRange.to)};
+          const replacementNode = structureContainer.childCount === 0 && controller.schema.node('placeholder', { placeholderText: 'Voer inhoud in'});
+          if(replacementNode){
+            tr.replaceRangeWith(oldStructureRange.from, oldStructureRange.to, replacementNode);
+          } else {
+            tr.delete(oldStructureRange.from, oldStructureRange.to);
+          }
+          return tr;
+        });
+        
+        const originalContainerRange = unwrap([...controller.datastore.match(`>${structureContainerURI as string}`).asSubjectNodeMapping().nodes()][0]);
+        const newContainerRange = unwrap([...controller.datastore.match(`>${newStructureContainerURI as string}`).asSubjectNodeMapping().nodes()][0]);
+        controller.doCommand(
+          recalculateStructureNumbers(
+            controller, 
+            originalContainerRange, 
+            currentStructureSpec,
+            options
+          )
+        );
+        controller.doCommand(
+          recalculateStructureNumbers(
+            controller, 
+            newContainerRange, 
+            currentStructureSpec,
+            options
+          )
+        );
+        recalculateContinuousStructures(controller, options);
+        const headingRange = unwrap([
+          ...controller.datastore
+            .match(`>${structureURI}`, 'ext:title')
+            .asPredicateNodeMapping()
+            .nodes(),
+        ][0]);
+        const newSelection = TextSelection.near(
+          controller.state.doc.resolve(headingRange.to)
+        );
+        controller.withTransaction((tr) => {
+          return tr.setSelection(newSelection);
+        });
+        controller.focus();
+      }
+      
+      return true;
+    }
+  };
+}
+
+function recalculateContinuousStructures(
+  controller: ProseController,
+  options: ResolvedArticleStructurePluginOptions
+) {
+  for (const structure of options.structures) {
+    if (structure.numbering === 'continuous') {
+      controller.doCommand(
+        recalculateStructureNumbers(controller, null, structure, options)
+      );
+    }
+  }
+}

package/addon/commands/article-structure-plugin/recalculate-structure-numbers.ts

@@ -0,0 +1,88 @@
+import { ProseController } from '@lblod/ember-rdfa-editor';
+import defaults from '@lblod/ember-rdfa-editor-lblod-plugins/utils/article-structure-plugin/defaults';
+import { Command } from 'prosemirror-state';
+import { ProseStore } from '@lblod/ember-rdfa-editor/utils/datastore/prose-store';
+import { expect } from '@lblod/ember-rdfa-editor/utils/option';
+import {
+  ResolvedArticleStructurePluginOptions,
+  StructureSpec,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/article-structure-plugin';
+
+export default function recalculateStructureNumbers(
+  controller: ProseController,
+  containerRange: { from: number; to: number } | undefined | null,
+  structureType: StructureSpec,
+  options: ResolvedArticleStructurePluginOptions
+): Command {
+  return (_state, dispatch) => {
+    if (dispatch) {
+      let datastore: ProseStore;
+      if (structureType.numbering !== 'continuous' && containerRange) {
+        datastore = controller.datastore.limitToRange(
+          controller.state,
+          containerRange.from,
+          containerRange.to,
+          'rangeContains'
+        );
+      } else {
+        datastore = controller.datastore;
+      }
+      const structureMatch = [
+        ...datastore
+          .match(null, 'a', `>${structureType.type}`)
+          .transformDataset((dataset) => {
+            return dataset.filter((quad) => {
+              return options.structureTypes.includes(quad.object.value);
+            });
+          })
+          .asSubjectNodeMapping(),
+      ];
+      const structures = structureMatch.map((match) => {
+        return {
+          uri: match.term.value,
+          range: match.nodes[0],
+        };
+      });
+      if (!structures.length) return true;
+      for (let i = 0; i < structures.length; i++) {
+        replaceNumberIfNeeded(controller, structures[i], i, structureType);
+      }
+    }
+    return true;
+  };
+}
+
+function replaceNumberIfNeeded(
+  controller: ProseController,
+  structure: { range: { from: number; to: number }; uri: string },
+  index: number,
+  structureType: StructureSpec
+) {
+  const numberPredicate =
+    structureType.numberPredicate || defaults.numberPredicate;
+  let structureNumberObjectNode = controller.datastore
+    .match(`>${structure.uri}`, `>${numberPredicate}`)
+    .asObjectNodeMapping()
+    .single();
+  structureNumberObjectNode = expect(
+    `${structure.uri} expected to have the predicate ${numberPredicate}`,
+    structureNumberObjectNode
+  );
+  const structureNumber = structureNumberObjectNode.term.value;
+  const structureNumberElement = structureNumberObjectNode.nodes[0];
+  if (!structureNumberElement) {
+    throw new Error('Could not find object node');
+  }
+  let structureNumberExpected: string;
+  if (structureType.numberingFunction) {
+    structureNumberExpected = structureType.numberingFunction(index + 1);
+  } else {
+    structureNumberExpected = (index + 1).toString();
+  }
+  if (structureNumber !== structureNumberExpected) {
+    const { from, to } = structureNumberElement;
+    controller.withTransaction((tr) => {
+      return tr.insertText(String(structureNumberExpected), from, to);
+    });
+  }
+}

package/addon/commands/besluit-plugin/get-article-nodes-for-besluit.ts

@@ -0,0 +1,30 @@
+import { ProseController } from '@lblod/ember-rdfa-editor';
+import { unwrap } from '@lblod/ember-rdfa-editor/utils/option';
+
+export default function getArticleNodesForBesluit(
+  controller: ProseController,
+  besluitUri?: string
+) {
+  if (!besluitUri) {
+    const selection = controller.state.selection;
+    besluitUri = controller.datastore
+      .limitToRange(controller.state, selection.from, selection.to)
+      .match(null, 'a', 'besluit:Besluit')
+      .asQuadResultSet()
+      .first()?.subject.value;
+  }
+  if (!besluitUri) {
+    return;
+  }
+  const articles = controller.datastore
+    .match(`>${besluitUri}`, 'eli:has_part')
+    .asObjectNodeMapping();
+  return [
+    ...articles.map((article) => {
+      return {
+        uri: article.term.value,
+        range: unwrap(article.nodes.shift()),
+      };
+    }),
+  ];
+}

package/addon/commands/besluit-plugin/index.ts

@@ -0,0 +1,4 @@
+export { default as insertArticle } from './insert-article';
+export { default as insertTitle } from './insert-title';
+export { default as moveArticle } from './move-article';
+export { default as recalculateArticleNumbers } from './recalculate-article-numbers';