@lblod/ember-rdfa-editor-lblod-plugins 11.1.0 → 11.3.0

package/addon/components/variable-plugin/codelist/insert.hbs

@@ -1,12 +1,22 @@
 <PowerSelect
   @allowClear={{false}}
   @searchEnabled={{false}}
-  @options={{this.subtypes.value}}
-  @selected={{this.selectedSubtype}}
-  @onChange={{this.updateSubtype}}
-  as |subtype|
+  @options={{this.codelistData.value}}
+  @selected={{this.selectedCodelist}}
+  @onChange={{this.selectCodelist}}
+  as |codelist|
 >
-  {{subtype.label}}
+  {{codelist.label}}
+</PowerSelect>
+<PowerSelect
+  @allowClear={{false}}
+  @searchEnabled={{false}}
+  @options={{this.selectionStyles}}
+  @selected={{this.selectedStyle}}
+  @onChange={{this.selectStyle}}
+  as |style|
+>
+  {{style.label}}
 </PowerSelect>
 <AuFormRow>
   <VariablePlugin::Utils::LabelInput 
@@ -16,7 +26,7 @@
 </AuFormRow>
 <AuButton
   {{on 'click' this.insert}}
-  @disabled={{not this.selectedSubtype}}
+  @disabled={{not this.selectedCodelist}}
 >
   {{t 'variable-plugin.button'}}
 </AuButton>

package/addon/components/variable-plugin/codelist/insert.ts

@@ -15,16 +15,22 @@ export type CodelistInsertOptions = {
   publisher?: string;
   endpoint: string;
 };
+
 type Args = {
   controller: SayController;
   options: CodelistInsertOptions;
 };
 
-export default class CodelistInsertComponent extends Component<Args> {
-  @tracked selectedSubtype?: CodeList;
-  @tracked label?: string;
+interface SelectStyle {
+  label: string;
+  value: string;
+}
 
+export default class CodelistInsertComponent extends Component<Args> {
   @service declare intl: IntlService;
+  @tracked selectedCodelist?: CodeList;
+  @tracked label?: string;
+  @tracked selectedStyleValue = 'single';
 
   get controller() {
     return this.args.controller;
@@ -42,9 +48,28 @@ export default class CodelistInsertComponent extends Component<Args> {
     return this.args.options.endpoint;
   }
 
-  subtypes = trackedFunction(this, async () => {
+  get selectionStyles() {
+    const singleSelect = {
+      label: this.intl.t('variable.codelist.single-select'),
+      value: 'single',
+    };
+    const multiSelect = {
+      label: this.intl.t('variable.codelist.multi-select'),
+      value: 'multi',
+    };
+    return [singleSelect, multiSelect];
+  }
+
+  get selectedStyle() {
+    return this.selectionStyles.find(
+      (style) => style.value === this.selectedStyleValue,
+    );
+  }
+
+  codelistData = trackedFunction(this, async () => {
     return fetchCodeListsByPublisher(this.endpoint, this.publisher);
   });
+
   @action
   updateLabel(event: InputEvent) {
     this.label = (event.target as HTMLInputElement).value;
@@ -58,12 +83,13 @@ export default class CodelistInsertComponent extends Component<Args> {
       {
         mappingResource,
         variableInstance,
-        codelistResource: this.selectedSubtype?.uri,
-        label: this.label ?? this.selectedSubtype?.label,
+        codelistResource: this.selectedCodelist?.uri,
+        label: this.label ?? this.selectedCodelist?.label,
         source: this.endpoint,
+        selectionStyle: this.selectedStyleValue,
       },
       this.schema.node('placeholder', {
-        placeholderText: this.selectedSubtype?.label,
+        placeholderText: this.selectedCodelist?.label,
       }),
     );
 
@@ -78,7 +104,12 @@ export default class CodelistInsertComponent extends Component<Args> {
   }
 
   @action
-  updateSubtype(subtype: CodeList) {
-    this.selectedSubtype = subtype;
+  selectCodelist(codelist: CodeList) {
+    this.selectedCodelist = codelist;
+  }
+
+  @action
+  selectStyle(style: SelectStyle) {
+    this.selectedStyleValue = style.value;
   }
 }

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

@@ -81,12 +81,17 @@ const MINISTERIAL = `ministerieel${NNWS}?besluit`;
  */
 const ENUM_ROYAL = `genummerd${NNWS}?${ROYAL}`;
 
+/**
+ * match for "decision of the flemish government"
+ */
+const DECISION = 'besluit';
+
 /**
  * The type of citation that we need to search for
  */
-const TYPE = `${DECREE}|${MEMO}|${TREATY}|${CONSTITUTION_CHANGE}|${COLLAB}|${BOOK}|${PROTOCOL}|${FLEMGOV}|${COORD}|${SPECIAL}|${LAW}|${ROYAL}|${MINISTERIAL}|${ENUM_ROYAL}`;
+const TYPE = `${DECREE}|${MEMO}|${TREATY}|${CONSTITUTION_CHANGE}|${COLLAB}|${BOOK}|${PROTOCOL}|${FLEMGOV}|${COORD}|${SPECIAL}|${LAW}|${ROYAL}|${MINISTERIAL}|${ENUM_ROYAL}|${DECISION}`;
 /**
- * The monster regex that makes the citation plugin trigger.
+ * The monster regex that makes the citation plugin trigger to show `CitationCard`.
  * In restructuring, I've made sure that I didn't abstract away any of the capturing groups,
  * only their content, so you can still see what's going on
  *
@@ -134,6 +139,7 @@ export type CitationPluginConfig =
 
 export type CitationPluginEmberComponentConfig = CitationPluginConfig & {
   endpoint: string;
+  decisionsEndpoint?: string;
 };
 
 export function citationPlugin(config: CitationPluginConfig): CitationPlugin {

package/addon/plugins/citation-plugin/utils/article.ts

@@ -0,0 +1,193 @@
+import { LegalDocumentsQueryConfig } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin/utils/legal-documents';
+import {
+  executeCountQuery,
+  executeQuery,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/utils/sparql-helpers';
+import {
+  dateValue,
+  escapeValue,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/utils/strings';
+import { Binding } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin/utils/types';
+
+interface ArticleArgs {
+  uri: string;
+  number?: number;
+  content: string | null;
+  dateInForce: string | null;
+  dateNoLongerInForce: string | null;
+}
+
+export class Article {
+  uri: string;
+  number?: number;
+  content: string | null;
+  dateInForce: string | null;
+  dateNoLongerInForce: string | null;
+
+  constructor({
+    uri,
+    number,
+    content,
+    dateInForce,
+    dateNoLongerInForce,
+  }: ArticleArgs) {
+    this.uri = uri;
+    this.number = number;
+    this.content = content;
+    this.dateInForce = dateInForce;
+    this.dateNoLongerInForce = dateNoLongerInForce;
+  }
+}
+
+export const fetchArticlesCache = new Map<string, ArticleCollection>();
+
+async function fetchArticles({
+  legalExpression,
+  pageNumber,
+  pageSize,
+  articleFilter,
+  config,
+}: {
+  legalExpression: string;
+  pageNumber: number;
+  pageSize: number;
+  articleFilter: string;
+  config: LegalDocumentsQueryConfig;
+}): Promise<ArticleCollection> {
+  //Simpler here, only one way arguments are set up
+  const stringArguments = JSON.stringify({
+    legalExpression,
+    pageNumber,
+    pageSize,
+    articleFilter,
+  });
+  const results = fetchArticlesCache.get(stringArguments);
+  if (results) {
+    return results;
+  } else {
+    const newResults = await fetchArticlesMemo({
+      legalExpression,
+      pageNumber,
+      pageSize,
+      articleFilter,
+      config,
+    });
+    fetchArticlesCache.set(stringArguments, newResults);
+    return newResults;
+  }
+}
+
+interface ArticleBinding {
+  count: Binding<string>;
+  content?: Binding<string>;
+  dateInForce?: Binding<string>;
+  dateNoLongerInForce?: Binding<string>;
+  article: Binding<string>;
+  number?: Binding<number>;
+}
+
+interface ArticleCollection {
+  totalCount: number;
+  articles: Article[];
+}
+
+async function fetchArticlesMemo({
+  legalExpression,
+  pageNumber = 0,
+  pageSize = 10,
+  articleFilter,
+  config,
+}: {
+  legalExpression: string;
+  pageNumber: number;
+  pageSize: number;
+  articleFilter: string;
+  config: LegalDocumentsQueryConfig;
+}): Promise<ArticleCollection> {
+  const numberFilter = articleFilter
+    ? `FILTER( !BOUND(?number) || CONTAINS(?number, "${articleFilter}"))`
+    : '';
+  const totalCount = await executeCountQuery({
+    query: `PREFIX eli: <http://data.europa.eu/eli/ontology#>
+    PREFIX dct: <http://purl.org/dc/terms/>
+
+    SELECT COUNT(DISTINCT(?article)) as ?count
+    WHERE {
+        ?legalResource eli:is_realized_by <${legalExpression}> ;
+                       eli:has_part ?articleResource .
+        ?articleResource eli:is_realized_by ?article ;
+                         dct:type <https://data.vlaanderen.be/id/concept/TypeRechtsbrononderdeel/Artikel>.
+        OPTIONAL {
+           ?article eli:first_date_entry_in_force ?dateInForce .
+           FILTER (?dateInForce <= NOW() )
+        }
+        OPTIONAL { ?article eli:date_no_longer_in_force ?dateNoLongerInForce }
+        FILTER( !BOUND(?dateNoLongerInForce) || ?dateNoLongerInForce > NOW() )
+        OPTIONAL { ?article eli:number ?number . }
+        ${numberFilter}
+    }`,
+    ...config,
+  });
+
+  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<ArticleBinding>({
+      query: `PREFIX eli: <http://data.europa.eu/eli/ontology#>
+      PREFIX prov: <http://www.w3.org/ns/prov#>
+      PREFIX dct: <http://purl.org/dc/terms/>
+
+      SELECT DISTINCT ?article ?dateInForce ?dateNoLongerInForce ?number ?content WHERE {
+          ?legalResource eli:is_realized_by <${legalExpression}> ;
+                         eli:has_part ?articleResource .
+          ?articleResource eli:is_realized_by ?article ;
+                           dct:type <https://data.vlaanderen.be/id/concept/TypeRechtsbrononderdeel/Artikel>.
+          OPTIONAL {
+            ?article eli:first_date_entry_in_force ?dateInForce .
+            FILTER (?dateInForce <= NOW() )
+          }
+          OPTIONAL { ?article eli:date_no_longer_in_force ?dateNoLongerInForce }
+          FILTER( !BOUND(?dateNoLongerInForce) || ?dateNoLongerInForce > NOW() )
+          OPTIONAL { ?article prov:value ?content . }
+          OPTIONAL { ?article eli:number ?number . }
+          ${numberFilter}
+          BIND(REPLACE(?number, "Artikel ", "") as ?numberStr)
+          BIND(STRDT(?numberStr, xsd:integer) as ?numberInt)
+      } ORDER BY ?numberInt ?numberStr LIMIT ${pageSize} OFFSET ${
+        pageNumber * pageSize
+      }`,
+      ...config,
+    });
+
+    const articles = response.results.bindings.map((binding) => {
+      const escapedContent = escapeValue(
+        binding.content && binding.content.value,
+      );
+      const dateInForce = dateValue(
+        binding.dateInForce && binding.dateInForce.value,
+      );
+      const dateNoLongerInForce = dateValue(
+        binding.dateNoLongerInForce && binding.dateNoLongerInForce.value,
+      );
+      return new Article({
+        uri: binding.article.value,
+        number: binding.number && binding.number.value,
+        content: escapedContent,
+        dateInForce,
+        dateNoLongerInForce,
+      });
+    });
+
+    return {
+      totalCount,
+      articles,
+    };
+  } else {
+    return {
+      totalCount,
+      articles: [],
+    };
+  }
+}
+
+export { fetchArticles };

package/addon/plugins/citation-plugin/utils/cache.ts

@@ -0,0 +1,7 @@
+import { fetchLegalDocumentsCache } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin/utils/legal-documents';
+import { fetchArticlesCache } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin/utils/article';
+
+export function cleanCaches() {
+  fetchLegalDocumentsCache.clear();
+  fetchArticlesCache.clear();
+}

package/addon/plugins/citation-plugin/utils/legal-documents.ts

@@ -0,0 +1,133 @@
+import {
+  isBesluitType,
+  LEGISLATION_TYPE_CONCEPTS,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin/utils/types';
+import { fetchVlaamseCodexLegalDocuments } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin/utils/vlaamse-codex';
+import { Option } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
+import { fetchPublicDecisions } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin/utils/public-decisions';
+
+interface LegalDocumentArgs {
+  uri: string;
+  legislationTypeUri: Option<string>;
+  title: string | null;
+  publicationDate: string | null;
+  documentDate: string | null;
+  meta?: Record<string, unknown> | null;
+}
+
+export class LegalDocument {
+  uri: string;
+  legislationType: { label: string; value: string } | undefined;
+  title: string | null;
+  publicationDate: string | null;
+  documentDate: string | null;
+  meta: Record<string, unknown> | null;
+
+  constructor({
+    uri,
+    legislationTypeUri,
+    title,
+    publicationDate,
+    documentDate,
+    meta,
+  }: LegalDocumentArgs) {
+    this.uri = uri;
+    this.legislationType = LEGISLATION_TYPE_CONCEPTS.find(
+      (t) => t.value === legislationTypeUri,
+    );
+    this.title = title;
+    this.publicationDate = publicationDate;
+    this.documentDate = documentDate;
+    this.meta = meta ?? null;
+  }
+
+  get fullTitle() {
+    return `${this.legislationType?.label ?? ''} ${this.title ?? ''}`;
+  }
+}
+
+export const isBesluitLegalDocument = (legalDocument: LegalDocument) =>
+  isBesluitType(legalDocument.legislationType?.value ?? '');
+
+export const fetchLegalDocumentsCache = new Map<
+  string,
+  LegalDocumentsCollection
+>();
+
+export interface LegalDocumentsCollection {
+  totalCount: number;
+  legalDocuments: LegalDocument[];
+}
+
+export interface LegalDocumentsQueryFilter {
+  type: string;
+  documentDateFrom?: Option<string>;
+  documentDateTo?: Option<string>;
+  publicationDateFrom?: Option<string>;
+  publicationDateTo?: Option<string>;
+}
+
+export type LegalDocumentsQueryConfig = {
+  endpoint: string;
+  decisionsEndpoint?: string;
+  abortSignal?: AbortSignal;
+};
+
+export async function fetchLegalDocuments({
+  words,
+  filter,
+  pageNumber = 0,
+  pageSize = 5,
+  config,
+}: {
+  words: string[];
+  filter: LegalDocumentsQueryFilter;
+  pageNumber: number;
+  pageSize: number;
+  config: LegalDocumentsQueryConfig;
+}) {
+  //This is silly, but null != undefined, so we have to be careful and include the correct value here
+  //Also, reconstruct the whole filter object to always have the same ordering, hopefully.
+  filter = {
+    type: filter.type,
+    documentDateFrom: filter.documentDateFrom || null,
+    documentDateTo: filter.documentDateTo || null,
+    publicationDateFrom: filter.publicationDateFrom || null,
+    publicationDateTo: filter.publicationDateTo || null,
+  };
+  const stringArguments = JSON.stringify({
+    words,
+    filter,
+    pageNumber,
+    pageSize,
+  });
+  const results = fetchLegalDocumentsCache.get(stringArguments);
+
+  if (results) {
+    return results;
+  } else {
+    const shouldQueryPublicDecisions =
+      isBesluitType(filter.type) && config.decisionsEndpoint;
+
+    const fetchConfig = {
+      words,
+      filter,
+      pageNumber,
+      pageSize,
+      config: {
+        endpoint: shouldQueryPublicDecisions
+          ? (config.decisionsEndpoint as string)
+          : config.endpoint,
+        abortSignal: config.abortSignal,
+      },
+    };
+
+    const newResults = shouldQueryPublicDecisions
+      ? await fetchPublicDecisions(fetchConfig)
+      : await fetchVlaamseCodexLegalDocuments(fetchConfig);
+
+    fetchLegalDocumentsCache.set(stringArguments, newResults);
+
+    return newResults;
+  }
+}

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

@@ -1,5 +1,5 @@
 import { isBlank } from '@ember/utils';
-import { LEGISLATION_TYPES } from './legislation-types';
+import { isLegislationType, LEGISLATION_TYPES } from './types';
 import { unwrap } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
 
 const STOP_WORDS = ['het', 'de', 'van', 'tot', 'dat'];
@@ -28,6 +28,44 @@ interface ProcessedMatch {
   };
 }
 
+const getTypeLabel = (
+  type: string,
+): keyof typeof LEGISLATION_TYPES | string => {
+  switch (true) {
+    case /\w+decreet/i.test(type):
+    case /decreet/i.test(type):
+      return 'decreet';
+    case /\w+wetboek/i.test(type):
+    case /wetboek/i.test(type):
+      return 'wetboek';
+    case /geco[oö]rdineerde[^\S\n]wet(ten)?/i.test(type):
+      return 'gecoördineerde wetten';
+    case /grondwets?wijziging/i.test(type):
+      return 'grondwetswijziging';
+    case /grondwet/i.test(type):
+      return 'grondwet';
+    case /bijzondere[^\S\n]wet/i.test(type):
+      return 'bijzondere wet';
+    case /\w+wet/i.test(type):
+    case /wet/i.test(type):
+      return 'wet';
+    default:
+      return type.toLowerCase().trim();
+  }
+};
+
+const getAugmentedSearchTerms = (type: string, searchTerms: string) => {
+  if (
+    /\w+decreet/i.test(type) ||
+    /\w+wetboek/i.test(type) ||
+    /\w+wet/i.test(type)
+  ) {
+    return `${type} ${searchTerms}`;
+  }
+
+  return searchTerms;
+};
+
 export default function processMatch(
   match: RegexpMatchArrayWithIndices,
 ): ProcessedMatch | null {
@@ -40,45 +78,23 @@ export default function processMatch(
   if (!type || !searchTerms) {
     return null;
   }
-  let cleanedSearchTerms = cleanupText(searchTerms)
+
+  const cleanedSearchTerms = cleanupText(searchTerms)
     .split(SPACES_REGEX)
     .filter(
       (word) => !isBlank(word) && word.length > 3 && !STOP_WORDS.includes(word),
     )
     .join(' ');
+
   if (type) {
-    let typeLabel: string;
-    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]wet(ten)?/i.test(type)) {
-      typeLabel = 'gecoördineerde wetten';
-    } else if (/grondwets?wijziging/i.test(type)) {
-      typeLabel = 'grondwetswijziging';
-    } else if (/grondwet/i.test(type)) {
-      typeLabel = 'grondwet';
-    } else if (/bijzondere[^\S\n]wet/i.test(type)) {
-      typeLabel = 'bijzondere wet';
-    } else if (/\w+wet/i.test(type)) {
-      typeLabel = 'wet';
-      cleanedSearchTerms = `${type} ${cleanedSearchTerms}`;
-    } else if (/wet/i.test(type)) {
-      typeLabel = 'wet';
-    } else {
-      typeLabel = type.toLowerCase().trim();
-    }
-    const typeUri =
-      (LEGISLATION_TYPES as Record<string, string>)[typeLabel] ||
-      LEGISLATION_TYPES['decreet'];
+    const typeLabel = getTypeLabel(type);
+
+    const typeUri = isLegislationType(typeLabel)
+      ? LEGISLATION_TYPES[typeLabel]
+      : LEGISLATION_TYPES['decreet'];
+
     return {
-      text: cleanedSearchTerms,
+      text: getAugmentedSearchTerms(type, cleanedSearchTerms),
       legislationTypeUri: typeUri,
       typeMatch: {
         text: type,
@@ -91,18 +107,18 @@ export default function processMatch(
         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],
-      },
-    };
   }
+
+  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 {