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

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/plugins/citation-plugin/utils/process-match.ts

@@ -0,0 +1,135 @@
+import { isBlank } from '@ember/utils';
+import {
+  LEGISLATION_TYPES,
+  LegislationKey,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/utils/legislation-types';
+import { unwrap } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
+
+const STOP_WORDS = ['het', 'de', 'van', 'tot', 'dat'];
+const DATE_REGEX = new RegExp('(\\d{1,2})\\s(\\w+)\\s(\\d{2,4})', 'g');
+const INVISIBLE_SPACE = '\u200B';
+const SPACES_REGEX = new RegExp('[\\s${UNBREAKABLE_SPACE}]+');
+export type RegexpMatchArrayWithIndices = RegExpMatchArray & {
+  indices: Array<[number, number]> & {
+    groups: { [key: string]: [number, number] };
+  };
+};
+
+interface ProcessedMatch {
+  text: string;
+  legislationTypeUri: string;
+  typeMatch: {
+    text: string;
+    start: number;
+    end: number;
+  } | null;
+  searchTextMatch: {
+    text: string;
+    start: number;
+    end: number;
+  };
+}
+
+export default function processMatch(
+  match: RegexpMatchArrayWithIndices
+): ProcessedMatch | null {
+  const matchgroups = match.groups;
+  if (!matchgroups) {
+    return null;
+  }
+  const type = matchgroups['type'];
+  const searchTerms = matchgroups['searchTerms'];
+  if (!type || !searchTerms) {
+    return null;
+  }
+  let cleanedSearchTerms = cleanupText(searchTerms)
+    .split(SPACES_REGEX)
+    .filter(
+      (word) => !isBlank(word) && word.length > 3 && !STOP_WORDS.includes(word)
+    )
+    .join(' ');
+  if (type) {
+    let typeLabel: LegislationKey;
+    if (/\w+decreet/i.test(type)) {
+      typeLabel = 'decreet';
+      cleanedSearchTerms = `${type} ${cleanedSearchTerms}`;
+    } else if (/decreet/i.test(type)) {
+      typeLabel = 'decreet';
+    } else if (/\w+wetboek/i.test(type)) {
+      typeLabel = 'wetboek';
+      cleanedSearchTerms = `${type} ${cleanedSearchTerms}`;
+    } else if (/wetboek/i.test(type)) {
+      typeLabel = 'wetboek';
+    } else if (/geco[oö]rdineerde[^\S\n]wetten/i.test(type)) {
+      typeLabel = 'gecoördineerde wetten';
+    } else if (/grondwetswijziging/i.test(type)) {
+      typeLabel = 'grondwetswijziging';
+    } else if (/grondwet/i.test(type)) {
+      typeLabel = 'grondwet';
+    } else if (/\w+wet/i.test(type)) {
+      typeLabel = 'wet';
+      cleanedSearchTerms = `${type} ${cleanedSearchTerms}`;
+    } else if (/wet/i.test(type)) {
+      typeLabel = 'wet';
+    } else {
+      typeLabel = 'decreet';
+    }
+    const typeUri = LEGISLATION_TYPES[typeLabel];
+    return {
+      text: cleanedSearchTerms,
+      legislationTypeUri: typeUri,
+      typeMatch: {
+        text: type,
+        start: unwrap(match.indices.groups['type'])[0],
+        end: unwrap(match.indices.groups['type'])[1],
+      },
+      searchTextMatch: {
+        text: searchTerms,
+        start: unwrap(match.indices.groups['searchTerms'])[0],
+        end: unwrap(match.indices.groups['searchTerms'])[1],
+      },
+    };
+  } else {
+    return {
+      text: cleanedSearchTerms,
+      legislationTypeUri: LEGISLATION_TYPES['decreet'],
+      typeMatch: null,
+      searchTextMatch: {
+        text: searchTerms,
+        start: unwrap(match.indices.groups['searchTerms'])[0],
+        end: unwrap(match.indices.groups['searchTerms'])[1],
+      },
+    };
+  }
+}
+
+function cleanupText(text?: string): string {
+  if (!text) return '';
+  const { textWithoutDates } = extractDates(text);
+  const textWithoutOddChars = textWithoutDates.replace(
+    new RegExp(`[,.:"()&${INVISIBLE_SPACE}]`, 'g'),
+    ''
+  );
+  const articleIndex = textWithoutOddChars.indexOf('artikel');
+  return articleIndex >= 0
+    ? textWithoutOddChars.slice(0, articleIndex)
+    : textWithoutOddChars;
+}
+
+function extractDates(text: string): {
+  dates: RegExpMatchArray[];
+  textWithoutDates: string;
+} {
+  let date;
+  const matches: RegExpMatchArray[] = [];
+  while ((date = DATE_REGEX.exec(text)) !== null) {
+    matches.push(date);
+  }
+
+  let textWithoutDates = text;
+  for (const match of matches) {
+    textWithoutDates = textWithoutDates.replace(match[0], '');
+  }
+
+  return { dates: matches, textWithoutDates };
+}