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

package/addon/plugins/citation-plugin/utils/process-match.ts

@@ -0,0 +1,132 @@
+import { isBlank } from '@ember/utils';
+import { LEGISLATION_TYPES, LegislationKey } from './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 };
+}

package/addon/{utils/vlaamse-codex.js → plugins/citation-plugin/utils/vlaamse-codex.ts}

@@ -1,21 +1,42 @@
 import { LEGISLATION_TYPE_CONCEPTS } from './legislation-types';
-const SPARQL_ENDPOINT = '/codex/sparql/';
 import { warn } from '@ember/debug';
 import { htmlSafe } from '@ember/template';
+import {
+  Option,
+  optionMapOr,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
+import Ember from 'ember';
+import SafeString = Ember.Handlebars.SafeString;
+
+const SPARQL_ENDPOINT = '/codex/sparql/';
 
 //const SPARQL_ENDPOINT = 'https://codex.opendata.api.vlaanderen.be:8888/sparql';
 
-class Decision {
+interface DecisionArgs {
+  uri: string;
+  legislationTypeUri: Option<string>;
+  title: string | null;
+  publicationDate: string | null;
+  documentDate: string | null;
+}
+
+export class Decision {
+  uri: string;
+  legislationType: { label: string; value: string } | undefined;
+  title: string | null;
+  publicationDate: string | null;
+  documentDate: string | null;
+
   constructor({
     uri,
     legislationTypeUri,
     title,
     publicationDate,
     documentDate,
-  }) {
+  }: DecisionArgs) {
     this.uri = uri;
     this.legislationType = LEGISLATION_TYPE_CONCEPTS.find(
-      (t) => t.value == legislationTypeUri
+      (t) => t.value === legislationTypeUri
     );
     this.title = title;
     this.publicationDate = publicationDate;
@@ -23,15 +44,35 @@ class Decision {
   }
 
   get fullTitle() {
-    return `${this.legislationType.label} ${this.title}`;
+    return `${this.legislationType?.label ?? ''} ${this.title ?? ''}`;
   }
 }
 
-class Article {
-  constructor({ uri, number, content, dateInForce, dateNoLongerInForce }) {
+interface ArticleArgs {
+  uri: string;
+  number?: number;
+  content: string | null;
+  dateInForce: string | null;
+  dateNoLongerInForce: string | null;
+}
+
+export class Article {
+  uri: string;
+  number?: number;
+  content: SafeString | null;
+  dateInForce: string | null;
+  dateNoLongerInForce: string | null;
+
+  constructor({
+    uri,
+    number,
+    content,
+    dateInForce,
+    dateNoLongerInForce,
+  }: ArticleArgs) {
     this.uri = uri;
     this.number = number;
-    this.content = htmlSafe(content);
+    this.content = optionMapOr(null, htmlSafe, content);
     this.dateInForce = dateInForce;
     this.dateNoLongerInForce = dateNoLongerInForce;
   }
@@ -41,12 +82,12 @@ class Article {
  * flemish codex encodes certain characters as a html character, which breaks our search
  * this is an ugly work around
  */
-function replaceDiacriticsInWord(word) {
+function replaceDiacriticsInWord(word: string): string {
   const characters =
     'Ë À Ì Â Í Ã Î Ä Ï Ç Ò È Ó É Ô Ê Õ Ö ê Ù ë Ú î Û ï Ü ô Ý õ â û ã ÿ ç'.split(
       ' '
     );
-  for (let char of characters) {
+  for (const char of characters) {
     word = word.replace(new RegExp(`${char}`, 'g'), `&#${char.charCodeAt(0)};`);
   }
   return word;
@@ -55,11 +96,19 @@ function replaceDiacriticsInWord(word) {
 //Attempt to memoise on the fetching by stringifying the arguments. This could spare a few fetches.
 //If memoising fails, at least a normal fetch is performed.
 
-const fetchDecisionsMemory = new Map();
+const fetchDecisionsMemory = new Map<string, DecisionCollection>();
+
+export interface QueryFilter {
+  type: string;
+  documentDateFrom?: Option<string>;
+  documentDateTo?: Option<string>;
+  publicationDateFrom?: Option<string>;
+  publicationDateTo?: Option<string>;
+}
 
 async function fetchDecisions(
-  words,
-  filter,
+  words: string[],
+  filter: QueryFilter,
   pageNumber = 0,
   pageSize = 5
   /*abortSignal*/
@@ -83,19 +132,29 @@ async function fetchDecisions(
   if (results) {
     return results;
   } else {
-    const newResults = await fetchDecisionsMemd(...arguments);
+    const newResults = await fetchDecisionsMemo(
+      words,
+      filter,
+      pageNumber,
+      pageSize
+    );
     fetchDecisionsMemory.set(stringArguments, newResults);
     return newResults;
   }
 }
 
-async function fetchDecisionsMemd(
-  words,
-  filter,
+interface DecisionCollection {
+  totalCount: number;
+  decisions: Decision[];
+}
+
+async function fetchDecisionsMemo(
+  words: string[],
+  filter: QueryFilter,
   pageNumber = 0,
   pageSize = 5,
-  abortSignal
-) {
+  abortSignal?: AbortSignal
+): Promise<DecisionCollection> {
   // TBD/NOTE: in the context of a <http://data.europa.eu/eli/ontology#LegalResource>
   // the eli:cites can have either a <http://xmlns.com/foaf/0.1/Document> or <http://data.europa.eu/eli/ontology#LegalResource>
   // as range (see AP https://data.vlaanderen.be/doc/applicatieprofiel/besluit-publicatie/#Rechtsgrond),
@@ -165,7 +224,7 @@ async function fetchDecisionsMemd(
   );
 
   if (totalCount > 0) {
-    const response = await executeQuery(
+    const response = await executeQuery<DecisionBinding>(
       `PREFIX eli: <http://data.europa.eu/eli/ontology#>
 
         SELECT DISTINCT ?expressionUri as ?uri ?title ?publicationDate ?documentDate
@@ -219,15 +278,26 @@ async function fetchDecisionsMemd(
   }
 }
 
-const fetchArticlesMemory = new Map();
+interface Binding<A> {
+  value: A;
+}
+
+interface DecisionBinding {
+  uri: Binding<string>;
+  title: Binding<string>;
+  publicationDate: Binding<string>;
+  documentDate: Binding<string>;
+}
+
+const fetchArticlesMemory = new Map<string, ArticleCollection>();
 
 async function fetchArticles(
-  legalExpression,
-  pageNumber,
-  pageSize,
-  articleFilter
+  legalExpression: string,
+  pageNumber: number,
+  pageSize: number,
+  articleFilter: string
   /*abortSignal*/
-) {
+): Promise<ArticleCollection> {
   //Simpler here, only one way arguments are set up
   const stringArguments = JSON.stringify({
     legalExpression,
@@ -239,19 +309,56 @@ async function fetchArticles(
   if (results) {
     return results;
   } else {
-    const newResults = await fetchArticlesMemd(...arguments);
+    const newResults = await fetchArticlesMemo(
+      legalExpression,
+      pageNumber,
+      pageSize,
+      articleFilter
+    );
     fetchArticlesMemory.set(stringArguments, newResults);
     return newResults;
   }
 }
 
-async function fetchArticlesMemd(
-  legalExpression,
+interface ArticleBinding {
+  count: {
+    value: string;
+  };
+  content?: {
+    value: string;
+  };
+  dateInForce?: {
+    value: string;
+  };
+  dateNoLongerInForce?: {
+    value: string;
+  };
+  article: {
+    value: string;
+  };
+  number?: {
+    value: number;
+  };
+}
+
+interface QueryResponse<B> {
+  results: {
+    bindings: B[];
+  };
+}
+
+interface ArticleCollection {
+  totalCount: number;
+  articles: Article[];
+}
+
+async function fetchArticlesMemo(
+  legalExpression: string,
   pageNumber = 0,
   pageSize = 10,
-  articleFilter,
-  abortSignal
-) {
+  articleFilter: string,
+  abortSignal?: AbortSignal
+): Promise<ArticleCollection> {
   const numberFilter = articleFilter
     ? `FILTER( !BOUND(?number) || CONTAINS(?number, "${articleFilter}"))`
     : '';
@@ -280,7 +387,7 @@ async function fetchArticlesMemd(
   if (totalCount > 0) {
     // ?number has format like "Artikel 12." We parse the number from the string for ordering
     // Second degree ordering on ?numberStr to make sure "Artikel 3/1." comes after "Artikel 3."
-    const response = await executeQuery(
+    const response = await executeQuery<ArticleBinding>(
       `PREFIX eli: <http://data.europa.eu/eli/ontology#>
       PREFIX prov: <http://www.w3.org/ns/prov#>
       PREFIX dct: <http://purl.org/dc/terms/>
@@ -343,7 +450,7 @@ function cleanCaches() {
   fetchArticlesMemory.clear();
 }
 
-function escapeValue(value) {
+function escapeValue(value?: string) {
   if (value) {
     const shadowDomElement = document.createElement('textarea');
     shadowDomElement.innerHTML = value;
@@ -353,14 +460,20 @@ function escapeValue(value) {
   }
 }
 
-function dateValue(value) {
+function dateValue(value?: string): string | null {
   if (value) {
     try {
       return new Intl.DateTimeFormat('nl-BE').format(
         new Date(Date.parse(value))
       );
     } catch (e) {
-      warn(`Error parsing date ${value}: ${e.message}`, {
+      let message: string;
+      if (e instanceof Error) {
+        message = e.message;
+      } else {
+        message = e as string;
+      }
+      warn(`Error parsing date ${value}: ${message}`, {
         id: 'date-parsing-error',
       });
       return null;
@@ -370,12 +483,18 @@ function dateValue(value) {
   }
 }
 
-async function executeCountQuery(query, abortSignal) {
-  const response = await executeQuery(query, abortSignal);
-  return parseInt(response.results.bindings[0].count.value);
+async function executeCountQuery(query: string, abortSignal?: AbortSignal) {
+  const response = await executeQuery<{ count: { value: string } }>(
+    query,
+    abortSignal
+  );
+  return optionMapOr(0, parseInt, response.results.bindings[0]?.count.value);
 }
 
-async function executeQuery(query, abortSignal) {
+async function executeQuery<A>(
+  query: string,
+  abortSignal?: AbortSignal
+): Promise<QueryResponse<A>> {
   const encodedQuery = encodeURIComponent(query.trim());
   const endpoint = `${SPARQL_ENDPOINT}`;
   const response = await fetch(endpoint, {
@@ -389,7 +508,7 @@ async function executeQuery(query, abortSignal) {
   });
 
   if (response.ok) {
-    return response.json();
+    return response.json() as Promise<QueryResponse<A>>;
   } else {
     throw new Error(
       `Request to Vlaamse Codex was unsuccessful: [${response.status}] ${response.statusText}`

package/addon/plugins/import-snippet-plugin.ts

@@ -0,0 +1,6 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+
+export const importSnippetWidget: WidgetSpec = {
+  componentName: 'import-snippet-plugin/card',
+  desiredLocation: 'sidebar',
+};

package/addon/plugins/insert-variable-plugin/index.ts

@@ -0,0 +1,11 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+
+export function insertVariableWidget(options?: unknown): WidgetSpec {
+  return {
+    componentName: 'insert-variable-plugin/insert-variable-card',
+    desiredLocation: 'sidebar',
+    widgetArgs: {
+      options,
+    },
+  };
+}

package/addon/{utils/variable-plugins/default-variable-types.js → plugins/insert-variable-plugin/utils/constants.ts}

@@ -1,6 +1,13 @@
-import { fetchCodeListsByPublisher } from './fetch-data';
+import { CodeList, fetchCodeListsByPublisher } from './fetch-data';
 
-export const defaultVariableTypes = {
+export type VariableType = {
+  label: string;
+  fetchSubtypes?: (endpoint: string, publisher: string) => Promise<CodeList[]>;
+  template:
+    | string
+    | ((endpoint: string, selectedCodelist?: CodeList) => string);
+};
+export const DEFAULT_VARIABLE_TYPES: Record<string, VariableType> = {
   text: {
     label: 'text',
     template: `
@@ -30,7 +37,7 @@ export const defaultVariableTypes = {
   },
   location: {
     label: 'location',
-    template: (endpoint) => `
+    template: (endpoint: string) => `
       <span property="dct:type" content="location"></span>
       <span property="dct:source" resource="${endpoint}"></span>
       <span property="ext:content">
@@ -40,16 +47,20 @@ export const defaultVariableTypes = {
   },
   codelist: {
     label: 'codelist',
-    fetchSubtypes: async (endpoint, publisher) => {
+    fetchSubtypes: async (endpoint: string, publisher: string) => {
       const codelists = fetchCodeListsByPublisher(endpoint, publisher);
       return codelists;
     },
-    template: (endpoint, selectedCodelist) => `
-      <span property="ext:codelist" resource="${selectedCodelist.uri}"></span>
+    template: (endpoint: string, selectedCodelist?: CodeList) => `
+      <span property="ext:codelist" resource="${
+        selectedCodelist?.uri ?? ''
+      }"></span>
       <span property="dct:type" content="codelist"></span>
       <span property="dct:source" resource="${endpoint}"></span>
       <span property="ext:content">
-        <span class="mark-highlight-manual">\${${selectedCodelist.label}}</span>
+        <span class="mark-highlight-manual">\${${
+          selectedCodelist?.label ?? ''
+        }}</span>
       </span>
     `,
   },

package/addon/plugins/insert-variable-plugin/utils/fetch-data.ts

@@ -0,0 +1,41 @@
+import { executeQuery } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/sparql-helpers';
+export type CodeList = {
+  uri?: string;
+  label?: string;
+};
+
+function generateCodeListsByPublisherQuery(publisher: string): string {
+  const codeListOptionsQuery = `
+    PREFIX lblodMobilitiet: <http://data.lblod.info/vocabularies/mobiliteit/>
+    PREFIX dct: <http://purl.org/dc/terms/>
+    PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
+    PREFIX mu: <http://mu.semte.ch/vocabularies/core/>
+    SELECT DISTINCT * WHERE { 
+      ?uri a lblodMobilitiet:Codelist;
+        skos:prefLabel ?label.
+      ${
+        publisher
+          ? `
+        ?uri dct:publisher <${publisher}>.
+      `
+          : ''
+      }
+    }
+  `;
+  return codeListOptionsQuery;
+}
+
+export async function fetchCodeListsByPublisher(
+  endpoint: string,
+  publisher: string
+): Promise<CodeList[]> {
+  const codelistsOptionsQueryResult = await executeQuery(
+    endpoint,
+    generateCodeListsByPublisherQuery(publisher)
+  );
+  const bindings = codelistsOptionsQueryResult.results.bindings;
+  return bindings.map((binding) => ({
+    uri: binding['uri']?.value,
+    label: binding['label']?.value,
+  }));
+}

package/addon/plugins/rdfa-date-plugin/commands/index.ts

@@ -0,0 +1 @@
+export { default as modifyDate } from './modify-date';

package/addon/plugins/rdfa-date-plugin/commands/modify-date.ts

@@ -0,0 +1,48 @@
+import { Command, Mark } from '@lblod/ember-rdfa-editor';
+import { unwrap } from '@lblod/ember-rdfa-editor/utils/option';
+
+function formatDate(date: Date, onlyDate: boolean) {
+  const options: Intl.DateTimeFormatOptions = {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    ...(!onlyDate && {
+      hour: '2-digit',
+      minute: '2-digit',
+    }),
+  };
+  return date.toLocaleString('nl-BE', options);
+}
+
+export default function modifyDate(
+  from: number,
+  to: number,
+  dateValue: Date,
+  onlyDate: boolean
+): Command {
+  return function (state, dispatch) {
+    if (dispatch) {
+      const transaction = state.tr;
+      const node = unwrap(transaction.doc.nodeAt(from));
+      const currentRdfaMark = node.marks
+        .filter((mark) => mark.type.name === 'inline_rdfa')
+        .at(-1);
+      if (currentRdfaMark) {
+        transaction.removeMark(from, to, currentRdfaMark);
+      }
+
+      const newMark: Mark = currentRdfaMark
+        ? state.schema.mark('inline_rdfa', {
+            ...currentRdfaMark.attrs,
+            content: dateValue.toISOString(),
+          })
+        : state.schema.mark('inline_rdfa', {
+            content: dateValue.toISOString(),
+          });
+      transaction.addMark(from, to, newMark);
+      transaction.insertText(formatDate(dateValue, onlyDate), from, to);
+      dispatch(transaction);
+    }
+    return true;
+  };
+}

package/addon/plugins/rdfa-date-plugin/index.ts

@@ -0,0 +1,11 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+
+export const rdfaDateCardWidget: WidgetSpec = {
+  componentName: 'rdfa-date-plugin/card',
+  desiredLocation: 'sidebar',
+};
+
+export const rdfaDateInsertWidget: WidgetSpec = {
+  componentName: 'rdfa-date-plugin/insert',
+  desiredLocation: 'insertSidebar',
+};

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

@@ -0,0 +1,6 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+
+export const roadSignRegulationWidget: WidgetSpec = {
+  componentName: 'roadsign-regulation-plugin/roadsign-regulation-card',
+  desiredLocation: 'insertSidebar',
+};

package/addon/plugins/roadsign-regulation-plugin/utils/constants.ts

@@ -0,0 +1,8 @@
+export const POTENTIALLY_ZONAL_URI =
+  'http://lblod.data.gift/concepts/8f9367b2-c717-4be7-8833-4c75bbb4ae1f';
+
+export const ZONAL_URI =
+  'http://lblod.data.gift/concepts/c81c6b96-736a-48cf-b003-6f5cc3dbc55d';
+
+export const NON_ZONAL_URI =
+  'http://lblod.data.gift/concepts/b651931b-923c-477c-8da9-fc7dd841fdcc';

package/addon/{utils/roadsign-regulation-plugin/fetchData.js → plugins/roadsign-regulation-plugin/utils/fetchData.ts}

@@ -1,6 +1,16 @@
-import { POTENTIALLY_ZONAL_URI } from '../../constants';
+import { POTENTIALLY_ZONAL_URI } from './constants';
 
-function buildFilters({ zonality, type, codes, category }) {
+function buildFilters({
+  zonality,
+  type,
+  codes,
+  category,
+}: {
+  zonality?: string;
+  type?: string;
+  codes?: string[];
+  category?: string;
+}) {
   const filters = [];
   if (zonality) {
     filters.push(
@@ -33,7 +43,14 @@ export function generateMeasuresQuery({
   codes,
   category,
   pageStart = 0,
-  count,
+  count = false,
+}: {
+  zonality?: string;
+  type?: string;
+  codes?: string[];
+  category?: string;
+  pageStart?: number;
+  count?: boolean;
 }) {
   const filters = buildFilters({ zonality, type, codes, category });
   let pagination = '';