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

package/addon/plugins/besluit-plugin/commands/insert-article.ts

@@ -0,0 +1,70 @@
+import { v4 as uuid } from 'uuid';
+import { insertHtml } from '@lblod/ember-rdfa-editor/commands/insert-html-command';
+import { ProseController, TextSelection } from '@lblod/ember-rdfa-editor';
+import { Command } from '@lblod/ember-rdfa-editor';
+import recalculateArticleNumbers from './recalculate-article-numbers';
+
+export default function insertArticle(
+  controller: ProseController,
+  articleContent: string
+): Command {
+  return function (_state, dispatch) {
+    const selection = controller.state.selection;
+    const limitedDatastore = controller.datastore.limitToRange(
+      controller.state,
+      selection.from,
+      selection.to
+    );
+    const besluitSubject = limitedDatastore
+      .match(null, 'a', '>http://data.vlaanderen.be/ns/besluit#Besluit')
+      .asQuadResultSet()
+      .first()?.subject;
+
+    if (!besluitSubject) {
+      return false;
+    }
+    const containerRange = [
+      ...controller.datastore
+        .match(besluitSubject, 'prov:value')
+        .asPredicateNodeMapping(),
+    ][0].nodes[0];
+
+    if (!containerRange) {
+      return false;
+    }
+    if (dispatch) {
+      const range = {
+        from: containerRange.to - 1,
+        to: containerRange.to - 1,
+      };
+      const articleUri = `http://data.lblod.info/artikels/${uuid()}`;
+      const articleHtml = `
+      <div property="eli:has_part" prefix="mobiliteit: https://data.vlaanderen.be/ns/mobiliteit#" typeof="besluit:Artikel" resource="${articleUri}">
+        <div>
+          Artikel
+          <span property="eli:number" datatype="xsd:string">
+            <span class="mark-highlight-manual">nummer</span>
+          </span></div>
+        <span style="display:none;" property="eli:language" resource="http://publications.europa.eu/resource/authority/language/NLD" typeof="skos:Concept">&nbsp;</span>
+        <div property="prov:value" datatype="xsd:string">
+        ${
+          articleContent
+            ? articleContent
+            : '<span class="mark-highlight-manual">Voer inhoud in</span>'
+        }
+        </div>
+      </div>
+    `;
+      controller.doCommand(insertHtml(articleHtml, range.from, range.to));
+      recalculateArticleNumbers(controller, besluitSubject.value);
+      controller.withTransaction((tr) => {
+        const selection = TextSelection.near(
+          controller.state.doc.resolve(range.from)
+        );
+        return tr.setSelection(selection).scrollIntoView();
+      });
+      controller.focus();
+    }
+    return true;
+  };
+}

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

@@ -0,0 +1,67 @@
+import {
+  Command,
+  ProseController,
+  TextSelection,
+} from '@lblod/ember-rdfa-editor';
+import { insertHtml } from '@lblod/ember-rdfa-editor/commands/insert-html-command';
+
+export default function insertTitle(
+  controller: ProseController,
+  title: string
+): Command {
+  return function (state, dispatch) {
+    const selection = controller.state.selection;
+    const limitedDatastore = controller.datastore.limitToRange(
+      controller.state,
+      selection.from,
+      selection.to
+    );
+
+    const besluit = [
+      ...limitedDatastore
+        .match(null, 'a', 'besluit:Besluit')
+        .asSubjectNodeMapping(),
+    ][0];
+
+    const besluitRange = besluit?.nodes[0];
+
+    if (!besluit || !besluitRange) {
+      return false;
+    }
+
+    const titleQuad = controller.datastore
+      .match(
+        `>${besluit.term.value}`,
+        '>http://data.europa.eu/eli/ontology#title'
+      )
+      .asQuadResultSet()
+      .first();
+    if (titleQuad) {
+      return false;
+    }
+
+    if (dispatch) {
+      const range = {
+        from: besluitRange.from + 1,
+        to: besluitRange.from + 1,
+      };
+      const articleHtml = `
+      <h4 class="h4" property="eli:title" datatype="xsd:string">${
+        title
+          ? title
+          : '<span class="mark-highlight-manual">Geef titel besluit op</span>'
+      }</h4>
+    `;
+      controller.doCommand(insertHtml(articleHtml, range.from, range.to));
+      controller.withTransaction((tr) => {
+        const selection = TextSelection.near(
+          controller.state.doc.resolve(range.from)
+        );
+        return tr.setSelection(selection).scrollIntoView();
+      });
+      dispatch(state.tr.scrollIntoView());
+    }
+
+    return true;
+  };
+}

package/addon/plugins/besluit-plugin/commands/move-article.ts

@@ -0,0 +1,69 @@
+import {
+  Command,
+  ProseController,
+  Selection,
+  TextSelection,
+} from '@lblod/ember-rdfa-editor';
+import recalculateArticleNumbers from './recalculate-article-numbers';
+import { ResolvedPNode } from '@lblod/ember-rdfa-editor/plugins/datastore';
+import { unwrap } from '@lblod/ember-rdfa-editor/utils/option';
+import getArticleNodesForBesluit from './get-article-nodes-for-besluit';
+
+export default function moveArticleCommand(
+  controller: ProseController,
+  besluitUri: string,
+  articleUri: string,
+  moveUp: boolean
+): Command {
+  return (_state, dispatch) => {
+    const articles = getArticleNodesForBesluit(controller, besluitUri);
+    if (!articles) {
+      return false;
+    }
+    const articleIndex = articles.findIndex(({ uri }) => uri === articleUri);
+
+    if (
+      articleIndex === -1 ||
+      (moveUp && articleIndex === 0) ||
+      (!moveUp && articleIndex === articles.length - 1)
+    ) {
+      return false;
+    }
+
+    if (dispatch) {
+      let articleA: ResolvedPNode;
+      let articleB: ResolvedPNode;
+
+      if (moveUp) {
+        articleA = unwrap(articles[articleIndex - 1]).range;
+        articleB = unwrap(articles[articleIndex]).range;
+      } else {
+        articleA = unwrap(articles[articleIndex]).range;
+        articleB = unwrap(articles[articleIndex + 1]).range;
+      }
+      const articleBNode = unwrap(controller.state.doc.nodeAt(articleB.from));
+      controller.withTransaction((tr) => {
+        tr.delete(articleB.from, articleB.to);
+        return tr.replaceRangeWith(articleA.from, articleA.from, articleBNode);
+      });
+      recalculateArticleNumbers(controller, besluitUri);
+      let selection: Selection;
+      if (moveUp) {
+        selection = TextSelection.near(
+          controller.state.doc.resolve(articleA.from)
+        );
+      } else {
+        selection = TextSelection.near(
+          controller.state.doc.resolve(
+            articleA.from + articleB.to - articleB.from
+          )
+        );
+      }
+      controller.withTransaction((tr) => {
+        return tr.setSelection(selection);
+      });
+      controller.focus();
+    }
+    return true;
+  };
+}

package/addon/plugins/besluit-plugin/commands/recalculate-article-numbers.ts

@@ -0,0 +1,44 @@
+import { ProseController } from '@lblod/ember-rdfa-editor';
+import { unwrap } from '@lblod/ember-rdfa-editor/utils/option';
+import getArticleNodesForBesluit from './get-article-nodes-for-besluit';
+
+export default function recalculateArticleNumbers(
+  controller: ProseController,
+  besluitUri: string
+) {
+  const articles = getArticleNodesForBesluit(controller, besluitUri);
+  if (articles) {
+    for (let i = 0; i < articles.length; i++) {
+      const article = unwrap(articles[i]);
+      replaceNumberIfNeeded(controller, article, i);
+    }
+  }
+}
+
+function replaceNumberIfNeeded(
+  controller: ProseController,
+  article: { uri: string; range: { from: number; to: number } },
+  index: number
+) {
+  const articleNumberObject = [
+    ...controller.datastore
+      .match(`>${article.uri}`, '>http://data.europa.eu/eli/ontology#number')
+      .asObjectNodeMapping(),
+  ][0];
+  if (!articleNumberObject) {
+    return;
+  }
+  const articleNumber = Number(articleNumberObject.term.value);
+  const articleNumberRange = unwrap(articleNumberObject.nodes[0]);
+  const articleNumberExpected = index + 1;
+
+  if (articleNumber !== articleNumberExpected) {
+    controller.withTransaction((tr) => {
+      return tr.insertText(
+        articleNumberExpected.toString(),
+        articleNumberRange.from,
+        articleNumberRange.to
+      );
+    });
+  }
+}

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

@@ -0,0 +1,11 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+
+export const besluitPluginCardWidget: WidgetSpec = {
+  componentName: 'besluit-plugin/besluit-plugin-card',
+  desiredLocation: 'insertSidebar',
+};
+
+export const besluitContextCardWidget: WidgetSpec = {
+  componentName: 'besluit-plugin/besluit-context-card',
+  desiredLocation: 'sidebar',
+};

package/addon/plugins/besluit-plugin/utils/get-title-for-decision.ts

@@ -0,0 +1,35 @@
+import { ProseStore } from '@lblod/ember-rdfa-editor/plugins/datastore';
+
+export function getTitleForDecision(
+  decisionUri: string,
+  datastore: ProseStore
+) {
+  const title = datastore
+    .match(`>${decisionUri}`, '>http://data.europa.eu/eli/ontology#title')
+    .asQuads()
+    .next().value;
+
+  return !!title;
+}
+
+/**
+ * Gets all nodes defining a eli:title predicate for a certain
+ * decision subject URI
+ * @param decisionUri
+ * @param datastore
+ * @returns {null|*}
+ */
+export function getTitleNodesForDecision(
+  decisionUri: string,
+  datastore: ProseStore
+) {
+  const mapping = datastore
+    .match(`>${decisionUri}`, '>http://data.europa.eu/eli/ontology#title')
+    .asPredicateNodeMapping()
+    .single();
+  if (mapping) {
+    return mapping.nodes;
+  } else {
+    return null;
+  }
+}

package/addon/plugins/besluit-type-plugin/index.ts

@@ -0,0 +1,6 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor/core/prosemirror';
+
+export const besluitTypeWidget: WidgetSpec = {
+  componentName: 'besluit-type-plugin/toolbar-dropdown',
+  desiredLocation: 'toolbarRight',
+};

package/addon/{utils/fetchBesluitTypes.js → plugins/besluit-type-plugin/utils/fetchBesluitTypes.ts}

@@ -1,6 +1,20 @@
-import { SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
+import { IBindings, SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
 
-export default async function fetchBesluitTypes(classificationUri, ENV) {
+export type BesluitType = {
+  uri: string;
+  definition: string;
+  label: string;
+  broader: string;
+  subTypes?: BesluitType[];
+};
+export default async function fetchBesluitTypes(
+  classificationUri: string,
+  ENV: {
+    besluitTypePlugin: {
+      endpoint: string;
+    };
+  }
+) {
   const query = `
     PREFIX                    conceptscheme: <https://data.vlaanderen.be/id/conceptscheme/>
     PREFIX                      BesluitType: <https://data.vlaanderen.be/id/concept/BesluitType/>
@@ -42,11 +56,11 @@ export default async function fetchBesluitTypes(classificationUri, ENV) {
   });
   const endpoint = ENV.besluitTypePlugin.endpoint;
   const bindingStream = await typeFetcher.fetchBindings(endpoint, query);
-  const validBesluitTriples = [];
-  bindingStream.on('data', (triple) => {
+  const validBesluitTriples: IBindings[] = [];
+  bindingStream.on('data', (triple: IBindings) => {
     validBesluitTriples.push(triple);
   });
-  return new Promise((resolve, reject) => {
+  return new Promise<IBindings[]>((resolve, reject) => {
     bindingStream.on('error', reject);
     bindingStream.on('end', () => {
       resolve(validBesluitTriples);
@@ -54,29 +68,34 @@ export default async function fetchBesluitTypes(classificationUri, ENV) {
   }).then(quadsToBesluitTypeObjects);
 }
 
-function quadsToBesluitTypeObjects(triples) {
-  const besluitTypes = new Map();
+function quadsToBesluitTypeObjects(triples: IBindings[]) {
+  const besluitTypes = new Map<string, BesluitType>();
   triples.forEach((triple) => {
-    const existing = besluitTypes.get(triple.s.value) || {
-      uri: triple.s.value,
-    };
-    switch (triple.p.value) {
+    const subject = triple['s'];
+    const predicate = triple['p'];
+    const object = triple['o'];
+    const existing =
+      besluitTypes.get(subject.value) ||
+      ({
+        uri: subject.value,
+      } as BesluitType);
+    switch (predicate.value) {
       case 'http://www.w3.org/2004/02/skos/core#definition':
-        existing.definition = triple.o.value;
+        existing.definition = object.value;
         break;
       case 'http://www.w3.org/2004/02/skos/core#prefLabel':
-        existing.label = triple.o.value;
+        existing.label = object.value;
         break;
       case 'http://www.w3.org/2004/02/skos/core#broader':
-        existing.broader = triple.o.value;
+        existing.broader = object.value;
         break;
     }
-    besluitTypes.set(triple.s.value, existing);
+    besluitTypes.set(subject.value, existing);
   });
   return createBesluitTypeObjectsHierarchy([...besluitTypes.values()]);
 }
 
-function createBesluitTypeObjectsHierarchy(allBesluitTypes) {
+function createBesluitTypeObjectsHierarchy(allBesluitTypes: BesluitType[]) {
   const besluitTypes = allBesluitTypes.filter((bst) => !bst.broader);
   const subTypes = allBesluitTypes.filter((bst) => !!bst.broader);
   subTypes.forEach((subtype) => {

package/addon/plugins/citation-plugin/index.ts

@@ -0,0 +1,216 @@
+import {
+  Decoration,
+  DecorationSet,
+  EditorState,
+  EditorStateConfig,
+  InlineDecorationSpec,
+  MarkSpec,
+  PNode,
+  ProsePlugin,
+  Schema,
+  WidgetSpec,
+} from '@lblod/ember-rdfa-editor';
+import {
+  datastoreKey,
+  ProseStore,
+} from '@lblod/ember-rdfa-editor/plugins/datastore';
+import processMatch, {
+  RegexpMatchArrayWithIndices,
+} from './utils/process-match';
+import { expect } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
+import { citation } from './marks/citation';
+
+const BASIC_MULTIPLANE_CHARACTER = '\u0021-\uFFFF'; // most of the characters used around the world
+
+// Regex nicely structured:
+// (
+//   (
+//     \w*decreet |
+//     omzendbrief |
+//     verdrag |
+//     grondwetswijziging |
+//     samenwerkingsakkoord |
+//     \w*wetboek |
+//     protocol |
+//     besluit[^\S\n]van[^\S\n]de[^\S\n]vlaamse[^\S\n]regering |
+//     geco[öo]rdineerde wetten |
+//     \w*wet |
+//     koninklijk[^\S\n]?besluit |
+//     ministerieel[^\S\n]?besluit |
+//     genummerd[^\S\n]?koninklijk[^\S\n]?besluit
+//   )
+//   [^\S\n]*
+//   (
+//     ([^\S\n] | [\u0021-\uFFFF\d;:'"()&\-_]){3,}
+//   )?
+// )
+const NNWS = '[^\\S\\n]';
+export const CITATION_REGEX = new RegExp(
+  `((?<type>\\w*decreet|omzendbrief|verdrag|grondwetswijziging|samenwerkingsakkoord|\\w*wetboek|protocol|besluit${NNWS}van${NNWS}de${NNWS}vlaamse${NNWS}regering|geco[öo]rdineerde${NNWS}wetten|\\w*wet|koninklijk${NNWS}?besluit|ministerieel${NNWS}?besluit|genummerd${NNWS}?koninklijk${NNWS}?besluit|\\w*${NNWS}?besluit)${NNWS}*(?<searchTerms>(${NNWS}|[${BASIC_MULTIPLANE_CHARACTER};:'"()&-_]){3,})?)`,
+  'uidg'
+);
+export type CitationSchema = Schema<string, 'citation'>;
+
+export interface CitationDecorationSpec extends InlineDecorationSpec {
+  legislationTypeUri: string;
+  searchText: string;
+}
+
+export interface CitationDecoration extends Decoration {
+  spec: CitationDecorationSpec;
+}
+
+function calculateDecorations(
+  schema: CitationSchema,
+  doc: PNode,
+  activeRanges: [number, number][]
+) {
+  const decorations: Decoration[] = [];
+
+  for (const [start, end] of activeRanges) {
+    doc.nodesBetween(start, end, (node: PNode, pos: number): boolean => {
+      if (
+        node.isText &&
+        node.text &&
+        !schema.marks.citation.isInSet(node.marks)
+      ) {
+        for (const match of node.text.matchAll(CITATION_REGEX)) {
+          const processedMatch = processMatch(
+            match as RegexpMatchArrayWithIndices
+          );
+
+          if (processedMatch) {
+            const { text, legislationTypeUri, searchTextMatch } =
+              processedMatch;
+            const { start: matchStart, end: matchEnd } = searchTextMatch;
+            const decorationStart = pos + matchStart;
+            const decorationEnd = pos + matchEnd;
+            decorations.push(
+              Decoration.inline(
+                decorationStart,
+                decorationEnd,
+
+                {
+                  'data-editor-highlight': 'true',
+                },
+                {
+                  searchText: text,
+                  legislationTypeUri,
+                }
+              )
+            );
+          }
+        }
+      }
+      return true;
+    });
+  }
+  return DecorationSet.create(doc, decorations);
+}
+
+interface CitationPluginState {
+  highlights: DecorationSet;
+  activeRanges: [number, number][];
+}
+
+export type CitationPlugin = ProsePlugin<CitationPluginState>;
+
+function citationPlugin({
+  activeIn = defaultActiveIn,
+}: CitationPluginConfig): CitationPlugin {
+  const citation: CitationPlugin = new ProsePlugin({
+    state: {
+      init(stateConfig: EditorStateConfig, state: EditorState) {
+        const { doc, schema } = state;
+        const activeRanges = activeIn(
+          state,
+          expect(
+            'the datastore plugin is required for this plugin',
+            datastoreKey.getState(state)
+          )
+        );
+        return {
+          highlights: calculateDecorations(schema, doc, activeRanges),
+          activeRanges,
+        };
+      },
+      apply(tr, set, oldState, newState) {
+        const { doc, schema } = newState;
+        const activeRanges = activeIn(
+          newState,
+          expect(
+            'the datastore plugin is required for this plugin',
+            datastoreKey.getState(newState)
+          )
+        );
+        return {
+          highlights: calculateDecorations(schema, doc, activeRanges),
+          activeRanges,
+        };
+      },
+    },
+    props: {
+      decorations(state): DecorationSet | undefined {
+        return citation.getState(state)?.highlights;
+      },
+    },
+  });
+  return citation;
+}
+
+function defaultActiveIn(
+  state: EditorState,
+  datastore: ProseStore
+): [number, number][] {
+  const result: [number, number][] = [];
+  for (const { from, to } of datastore
+    .match(null, 'besluit:motivering')
+    .asPredicateNodeMapping()
+    .nodes()) {
+    result.push([from, to]);
+  }
+  return result;
+}
+
+export interface CitationPluginBundle {
+  plugin: ProsePlugin<CitationPluginState>;
+  widgets: {
+    citationCard: WidgetSpec;
+    citationInsert: WidgetSpec;
+  };
+  marks: {
+    citation: MarkSpec;
+  };
+}
+
+export interface CitationPluginConfig {
+  activeIn?(state: EditorState, datastore: ProseStore): [number, number][];
+}
+
+export function setupCitationPlugin(
+  config: CitationPluginConfig = {}
+): CitationPluginBundle {
+  const plugin = citationPlugin(config);
+  return {
+    plugin,
+    widgets: {
+      citationCard: {
+        desiredLocation: 'sidebar',
+        componentName: 'citation-plugin/citation-card',
+        widgetArgs: {
+          plugin,
+        },
+      },
+      citationInsert: {
+        desiredLocation: 'insertSidebar',
+        componentName: 'citation-plugin/citation-insert',
+        widgetArgs: {
+          plugin,
+        },
+      },
+    },
+    marks: {
+      citation,
+    },
+  };
+}

package/addon/plugins/citation-plugin/marks/citation.ts

@@ -0,0 +1,27 @@
+import { getRdfaAttrs, MarkSpec, rdfaAttrs } from '@lblod/ember-rdfa-editor';
+
+export const citation: MarkSpec = {
+  attrs: { test: { default: 'yeet' }, ...rdfaAttrs },
+  inclusive: false,
+  group: 'linkmarks',
+  excludes: 'linkmarks',
+  parseDOM: [
+    {
+      tag: 'a[href]',
+      getAttrs(dom) {
+        if (typeof dom === 'string') {
+          return false;
+        }
+        const type = dom.attributes.getNamedItem('typeof')?.value;
+        const property = dom.attributes.getNamedItem('property')?.value;
+        if (type === 'eli:LegalExpression' && property === 'eli:cites') {
+          return getRdfaAttrs(dom);
+        }
+        return false;
+      },
+    },
+  ],
+  toDOM(node) {
+    return ['a', { ...node.attrs, class: 'annotation' }, 0];
+  },
+};

package/addon/plugins/citation-plugin/utils/cited-text.ts

@@ -0,0 +1,17 @@
+import { PNode } from '@lblod/ember-rdfa-editor';
+import { CitationSchema } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin';
+import { unwrap } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
+
+export function citedText(
+  schema: CitationSchema,
+  title: string,
+  uri: string
+): PNode {
+  return schema.text(title, [
+    unwrap(schema.marks.citation).create({
+      href: uri,
+      property: 'eli:cites',
+      typeof: 'eli:LegalExpression',
+    }),
+  ]);
+}

package/addon/{utils/legislation-types.js → plugins/citation-plugin/utils/legislation-types.ts}

@@ -25,8 +25,22 @@ const LEGISLATION_TYPES = {
   protocol: 'https://data.vlaanderen.be/id/concept/AardWetgeving/Protocol',
 };
 
-const LEGISLATION_TYPE_CONCEPTS = Object.keys(LEGISLATION_TYPES).map((key) => {
-  return { label: key, value: LEGISLATION_TYPES[key] };
-});
+export type Legislations = typeof LEGISLATION_TYPES;
+export type LegislationKey = keyof Legislations;
+// export type MappedLegislations = {
+//   [K in LegislationKey]: {
+//     label: K;
+//     value: Legislations[K];
+//   };
+// };
+// export type MappedLegislation = MappedLegislations[LegislationKey];
+const LEGISLATION_TYPE_CONCEPTS = Object.entries(LEGISLATION_TYPES).map(
+  (pair: [string, string]) => {
+    return {
+      label: pair[0],
+      value: pair[1],
+    };
+  }
+);
 
 export { LEGISLATION_TYPES, LEGISLATION_TYPE_CONCEPTS };