@lblod/ember-rdfa-editor-lblod-plugins 0.3.0 → 0.4.0

package/addon/components/template-variable-plugin/template-variable-card.js

@@ -0,0 +1,230 @@
+import Component from '@glimmer/component';
+import { tracked } from '@glimmer/tracking';
+import { action } from '@ember/object';
+import { getOwner } from '@ember/application';
+import { task } from 'ember-concurrency';
+
+import { fetchCodeListOptions } from '../../utils/variable-plugins/fetch-data';
+import { MULTI_SELECT_CODELIST_TYPE, ZONAL_URI } from '../../constants';
+
+export default class EditorPluginsTemplateVariableCardComponent extends Component {
+  @tracked variableOptions = [];
+  @tracked selectedVariable;
+  @tracked showCard = false;
+  @tracked multiSelect = false;
+  mappingUri;
+
+  constructor() {
+    super(...arguments);
+    const config = getOwner(this).resolveRegistration('config:environment');
+    this.zonalLocationCodelistUri =
+      config.templateVariablePlugin.zonalLocationCodelistUri;
+    this.endpoint = config.templateVariablePlugin.endpoint;
+    this.nonZonalLocationCodelistUri =
+      config.templateVariablePlugin.nonZonalLocationCodelistUri;
+    this.args.controller.onEvent('selectionChanged', this.selectionChanged);
+    this.liveHighlights = this.args.controller.createLiveMarkSet({
+      datastoreQuery: (datastore) => {
+        const limitedDataset = datastore.transformDataset(
+          (dataset, termconverter) => {
+            const mappings = dataset.match(
+              null,
+              termconverter('a'),
+              termconverter('ext:Mapping')
+            );
+            const locations = dataset.match(
+              null,
+              termconverter('>http://purl.org/dc/terms/type'),
+              termconverter('@en-US"location')
+            );
+            const codelists = dataset.match(
+              null,
+              termconverter('>http://purl.org/dc/terms/type'),
+              termconverter('@en-US"codelist')
+            );
+            const supportedMappings = locations.union(codelists);
+            return mappings.filter(
+              (quad) => supportedMappings.match(quad.subject).size !== 0
+            );
+          }
+        );
+        const matches = limitedDataset.searchTextIn(
+          'subject',
+          new RegExp('.*')
+        );
+        return matches;
+      },
+
+      liveMarkSpecs: ['highlighted'],
+    });
+  }
+
+  @action
+  insert() {
+    const selectedRange = this.args.controller.selection.lastRange;
+    if (!selectedRange) {
+      return;
+    }
+    const limitedDatastore = this.args.controller.datastore.limitToRange(
+      selectedRange,
+      'rangeIsInside'
+    );
+    const mapping = limitedDatastore
+      .match(`>${this.mappingUri}`, 'ext:content', null)
+      .asSubjectNodes()
+      .next().value;
+    const mappingNode = [...mapping.nodes][0];
+    let mappingContentNode;
+    for (let child of mappingNode.children) {
+      if (child.attributeMap.get('property') === 'ext:content') {
+        mappingContentNode = child;
+        break;
+      }
+    }
+    let textToInsert = '';
+    if (this.selectedVariable.length) {
+      textToInsert = this.selectedVariable
+        .map((variable) => variable.value)
+        .join(', ');
+    } else {
+      textToInsert = this.selectedVariable.value;
+    }
+    textToInsert = this.wrapVariableInHighlight(textToInsert);
+    this.args.controller.executeCommand(
+      'insert-and-collapse',
+      this.args.controller,
+      textToInsert,
+      mappingContentNode
+    );
+  }
+
+  wrapVariableInHighlight(text) {
+    return text.replace(
+      /\$\{(.+?)\}/g,
+      '<span class="mark-highlight-manual">${$1}</span>'
+    );
+  }
+
+  @action
+  selectionChanged() {
+    this.showCard = false;
+    this.selectedVariable = undefined;
+    const selectedRange = this.args.controller.selection.lastRange;
+    if (!selectedRange) {
+      return;
+    }
+    const fullDatastore = this.args.controller.datastore;
+    const limitedDatastore = this.args.controller.datastore.limitToRange(
+      selectedRange,
+      'rangeIsInside'
+    );
+    const mapping = limitedDatastore
+      .match(null, 'a', 'ext:Mapping')
+      .asQuads()
+      .next().value;
+    console.log('MAPPING: ', mapping);
+    if (mapping) {
+      const mappingUri = mapping.subject.value;
+      this.mappingUri = mappingUri;
+      const mappingTypeTriple = fullDatastore
+        .match(`>${mappingUri}`, 'dct:type', null)
+        .asQuads()
+        .next().value;
+      console.log('TRIPLE: ', mappingTypeTriple);
+      if (mappingTypeTriple) {
+        const mappingType = mappingTypeTriple.object.value;
+        if (mappingType === 'codelist') {
+          const codelistTriple = fullDatastore
+            .match(`>${mappingUri}`, 'ext:codelist', null)
+            .asQuads()
+            .next().value;
+          const codelistSource = this.getCodelistSource(
+            fullDatastore,
+            mappingUri
+          );
+          this.showCard = true;
+          const codelistUri = codelistTriple.object.value;
+          this.fetchCodeListOptions.perform(codelistSource, codelistUri);
+        } else if (mappingType === 'location') {
+          const codelistSource = this.getCodelistSource(
+            fullDatastore,
+            mappingUri
+          );
+          const measureTriple = limitedDatastore
+            .match(
+              null,
+              'a',
+              '>https://data.vlaanderen.be/ns/mobiliteit#Mobiliteitsmaatregel'
+            )
+            .asQuads()
+            .next().value;
+          const measureUri = measureTriple.subject.value;
+          const zonalityTriple = fullDatastore
+            .match(`>${measureUri}`, 'ext:zonality', null)
+            .asQuads()
+            .next().value;
+          const zonalityUri = zonalityTriple.object.value;
+          if (zonalityUri === ZONAL_URI) {
+            this.fetchCodeListOptions.perform(
+              codelistSource,
+              this.zonalLocationCodelistUri,
+              true
+            );
+          } else {
+            this.fetchCodeListOptions.perform(
+              codelistSource,
+              this.nonZonalLocationCodelistUri,
+              true
+            );
+          }
+          this.showCard = true;
+        }
+      }
+    }
+  }
+
+  getCodelistSource(fullDatastore, mappingUri) {
+    const codelistSourceTriple = fullDatastore
+      .match(`>${mappingUri}`, 'dct:source', null)
+      .asQuads()
+      .next();
+
+    if (codelistSourceTriple && codelistSourceTriple.value) {
+      const codelistSourceTripleValue = codelistSourceTriple.value;
+      return codelistSourceTripleValue.object.value;
+    } else {
+      return this.endpoint;
+    }
+  }
+
+  @action
+  updateVariable(variable) {
+    this.selectedVariable = variable;
+  }
+
+  @task
+  *fetchCodeListOptions(endpoint, codelistUri, isLocation) {
+    const { type, options } = yield fetchCodeListOptions(endpoint, codelistUri);
+    if (isLocation) {
+      this.variableOptions = options.map((option) => ({
+        label: option.label,
+        value: this.wrapInLocation(option.value),
+      }));
+    } else {
+      this.variableOptions = options;
+    }
+    if (type === MULTI_SELECT_CODELIST_TYPE) {
+      this.multiSelect = true;
+    } else {
+      this.multiSelect = false;
+    }
+  }
+
+  wrapInLocation(value) {
+    return `
+      <span property="https://data.vlaanderen.be/ns/mobiliteit#plaatsbepaling">
+        ${value}
+      </span>
+    `;
+  }
+}

package/addon/constants.js

@@ -0,0 +1,24 @@
+export const TABLE_OF_CONTENTS_DEFAULT_CONFIG = [
+  {
+    sectionPredicate: 'https://say.data.gift/ns/hasPart',
+    value: {
+      predicate: 'https://say.data.gift/ns/heading',
+    },
+  },
+  {
+    sectionPredicate: 'https://say.data.gift/ns/hasParagraph',
+    value: '§',
+  },
+];
+
+export const ZONAL_URI =
+  'http://lblod.data.gift/concepts/c81c6b96-736a-48cf-b003-6f5cc3dbc55d';
+
+export const POTENTIALLY_ZONAL_URI =
+  'http://lblod.data.gift/concepts/8f9367b2-c717-4be7-8833-4c75bbb4ae1f';
+
+export const NON_ZONAL_URI =
+  'http://lblod.data.gift/concepts/b651931b-923c-477c-8da9-fc7dd841fdcc';
+
+export const MULTI_SELECT_CODELIST_TYPE =
+  'http://lblod.data.gift/concepts/57C93E12-A02C-4D4B-8B95-666B6701286C';

package/{dist → addon}/helpers/limit-text.js

@@ -1,12 +1,9 @@
 import { helper } from '@ember/component/helper';
 
-var limitText = helper(function limitText([string]) {
+export default helper(function limitText([string]) {
   if (string.length > 140) {
     return string.slice(0, 140) + '...';
   } else {
     return string;
   }
 });
-
-export { limitText as default };
-//# sourceMappingURL=limit-text.js.map

package/addon/initializers/plugin-initializer.js

@@ -0,0 +1,75 @@
+import BesluitTypePlugin from '../plugins/besluit-type-plugin';
+import CitatenPlugin from '../plugins/citaten-plugin';
+import StandardTemplatePlugin from '../plugins/standard-template-plugin';
+import GenerateTemplatePlugin from '../plugins/generate-template-plugin';
+import RoadSignRegulationPlugin from '../plugins/roadsign-regulation-plugin';
+import TableOfContentsPlugin from '../plugins/table-of-contents-plugin';
+import RdfaDatePlugin from '../plugins/rdfa-date-plugin';
+import ImportSnippetPlugin from '../plugins/import-snippet-plugin';
+import TemplateVariablePlugin from '../plugins/template-variable-plugin';
+import InsertVariablePlugin from '../plugins/insert-variable-plugin';
+
+function pluginFactory(plugin) {
+  return {
+    create: (initializers) => {
+      const pluginInstance = new plugin();
+      Object.assign(pluginInstance, initializers);
+      return pluginInstance;
+    },
+  };
+}
+
+export function initialize(application) {
+  application.register('plugin:citaten', pluginFactory(CitatenPlugin), {
+    singleton: false,
+  });
+  application.register(
+    'plugin:standard-template',
+    pluginFactory(StandardTemplatePlugin),
+    { singleton: false }
+  );
+  application.register(
+    'plugin:besluit-type',
+    pluginFactory(BesluitTypePlugin),
+    { singleton: false }
+  );
+  application.register(
+    'plugin:table-of-contents',
+    pluginFactory(TableOfContentsPlugin),
+    { singleton: false }
+  );
+  application.register(
+    'plugin:generate-template',
+    pluginFactory(GenerateTemplatePlugin),
+    { singleton: false }
+  );
+  application.register(
+    'plugin:roadsign-regulation',
+    pluginFactory(RoadSignRegulationPlugin),
+    { singleton: false }
+  );
+  application.register('plugin:rdfa-date', pluginFactory(RdfaDatePlugin), {
+    singleton: false,
+  });
+  application.register(
+    'plugin:import-snippet',
+    pluginFactory(ImportSnippetPlugin),
+    {
+      singleton: false,
+    }
+  );
+  application.register(
+    'plugin:template-variable',
+    pluginFactory(TemplateVariablePlugin),
+    { singleton: false }
+  );
+  application.register(
+    'plugin:insert-variable',
+    pluginFactory(InsertVariablePlugin),
+    { singleton: false }
+  );
+}
+
+export default {
+  initialize,
+};

package/addon/inline-components/table-of-contents.js

@@ -0,0 +1,43 @@
+import { InlineComponentSpec } from '@lblod/ember-rdfa-editor/model/inline-components/model-inline-component';
+import { isElement } from '@lblod/ember-rdfa-editor/utils/dom-helpers';
+import { TABLE_OF_CONTENTS_DEFAULT_CONFIG } from '../constants';
+export default class TableOfContentsSpec extends InlineComponentSpec {
+  matcher = {
+    tag: this.tag,
+    attributeBuilder: (node) => {
+      if (isElement(node)) {
+        if (
+          (node.classList.contains('inline-component') &&
+            (node.classList.contains(this.name) ||
+              node.classList.contains(
+                'inline-components/table-of-contents'
+              ))) ||
+          node.dataset.inlineComponent === this.name ||
+          node.dataset.inlineComponent === 'inline-components/table-of-contents'
+        ) {
+          return {};
+        }
+      }
+      return null;
+    },
+  };
+
+  properties = {
+    config: {
+      serializable: true,
+      defaultValue: TABLE_OF_CONTENTS_DEFAULT_CONFIG,
+    },
+  };
+
+  _renderStatic() {
+    // TODO: should be implemented when static version of inline components work correctly
+    return '';
+  }
+  constructor(controller) {
+    super(
+      'table-of-contents-plugin/inline-components/table-of-contents',
+      'div',
+      controller
+    );
+  }
+}

package/addon/marks/citaten-mark.js

@@ -0,0 +1,32 @@
+const citatenMarkSpec = {
+  matchers: [
+    {
+      tag: 'span',
+      attributeBuilder: (node) => {
+        if (
+          node.dataset &&
+          Object.prototype.hasOwnProperty.call(node.dataset, 'citatenText')
+        ) {
+          return {
+            text: node.dataset.citatenText,
+            legislationTypeUri: node.dataset.legislationTypeUri,
+          };
+        }
+      },
+    },
+  ],
+  name: 'citaten',
+  priority: 100,
+  renderSpec(mark) {
+    return {
+      tag: 'span',
+      attributes: {
+        'data-citaten-text': mark.attributes.text,
+        'data-legislation-type-uri': mark.attributes.legislationTypeUri,
+      },
+      children: [0],
+    };
+  },
+};
+
+export default citatenMarkSpec;

package/addon/models/instruction.js

@@ -0,0 +1,19 @@
+export default class Instruction {
+  name;
+  template;
+  annotatedTemplate;
+
+  static fromBinding(binding) {
+    return new Instruction(
+      binding.name.value,
+      binding.template.value,
+      binding.annotatedTemplate.value
+    );
+  }
+
+  constructor(name, template, annotatedTemplate) {
+    this.name = name;
+    this.template = template;
+    this.annotatedTemplate = annotatedTemplate;
+  }
+}

package/addon/models/measure.js

@@ -0,0 +1,46 @@
+import { tracked } from '@glimmer/tracking';
+
+export default class Measure {
+  label;
+  @tracked signs = [];
+  template;
+  classifications = new Set();
+  annotatedTemplate;
+  zonality;
+  temporal;
+
+  static fromBinding(binding) {
+    const uri = binding.uri.value;
+    const label = binding.label.value;
+    const template = binding.basicTemplate.value;
+    const temporal = binding.temporal ? binding.temporal.value : false;
+    const annotatedTemplate = binding.annotatedTemplate.value;
+    const zonality = binding.zonality.value;
+    return new Measure(
+      uri,
+      label,
+      template,
+      annotatedTemplate,
+      zonality,
+      temporal
+    );
+  }
+
+  constructor(
+    uri,
+    label,
+    template,
+    annotatedTemplate,
+    zonality,
+    temporal,
+    signs = null
+  ) {
+    this.label = label;
+    this.uri = uri;
+    this.template = template;
+    this.zonality = zonality;
+    this.annotatedTemplate = annotatedTemplate;
+    this.signs = signs;
+    this.temporal = temporal;
+  }
+}

package/{dist → addon}/models/sign.js

@@ -1,22 +1,24 @@
-import { b as _defineProperty } from '../_rollupPluginBabelHelpers-537ad14b.js';
-
-class Sign {
+export default class Sign {
+  code;
+  image;
+  classifications = [];
+  uri;
+  order;
+  zonality;
   static fromBinding(binding) {
     const code = binding.code.value;
     const image = Sign.processImage(binding.image.value, binding.imageBaseUrl);
+
     const uri = binding.uri.value;
     const order = binding.order.value;
-    const classifications = binding.classifications ? binding.classifications.value.split('|') : [];
+    const classifications = binding.classifications
+      ? binding.classifications.value.split('|')
+      : [];
     const zonality = binding.zonality.value;
     return new Sign(code, image, classifications, uri, order, zonality);
   }
+
   constructor(code, image, classifications, uri, order, zonality) {
-    _defineProperty(this, "code", void 0);
-    _defineProperty(this, "image", void 0);
-    _defineProperty(this, "classifications", []);
-    _defineProperty(this, "uri", void 0);
-    _defineProperty(this, "order", void 0);
-    _defineProperty(this, "zonality", void 0);
     this.code = code;
     this.image = image;
     this.classifications = classifications;
@@ -33,6 +35,3 @@ class Sign {
     }
   }
 }
-
-export { Sign as default };
-//# sourceMappingURL=sign.js.map

package/addon/models/template.js

@@ -0,0 +1,9 @@
+import Model, { attr } from '@ember-data/model';
+
+export default class TemplateModel extends Model {
+  @attr title;
+  @attr('string-set', { defaultValue: () => [] }) matches;
+  @attr body;
+  @attr('string-set', { defaultValue: () => [] }) contexts;
+  @attr('string-set', { defaultValue: () => [] }) disabledInContexts;
+}

package/addon/plugins/besluit-type-plugin.js

@@ -0,0 +1,16 @@
+export default class BesluitTypePlugin {
+  controller;
+
+  get name() {
+    return 'besluit-type-plugin';
+  }
+
+  initialize(controller) {
+    this.controller = controller;
+    controller.registerWidget({
+      componentName: 'besluit-type-plugin/toolbar-dropdown',
+      identifier: 'besluit-type-plugin/dropdown',
+      desiredLocation: 'toolbar',
+    });
+  }
+}

package/addon/plugins/citaten-plugin.js

@@ -0,0 +1,22 @@
+import CitatenMark from '../marks/citaten-mark';
+export default class CitatenPlugin {
+  controller;
+
+  get name() {
+    return 'citaten-plugin';
+  }
+  async initialize(controller) {
+    this.controller = controller;
+    controller.registerWidget({
+      desiredLocation: 'sidebar',
+      componentName: 'citaten-plugin/citaat-card',
+      identifier: 'citaten-plugin/citaat-card',
+    });
+    controller.registerWidget({
+      desiredLocation: 'insertSidebar',
+      componentName: 'citaten-plugin/citaat-insert',
+      identifier: 'citaten-plugin/citaat-insert',
+    });
+    controller.registerMark(CitatenMark);
+  }
+}

package/addon/plugins/generate-template-plugin.js

@@ -0,0 +1,16 @@
+import GenerateTemplateCommand from '../commands/generate-template-command';
+
+export default class GenerateTemplatePlugin {
+  controller;
+
+  get name() {
+    return 'generate-template-plugin';
+  }
+
+  initialize(controller) {
+    this.controller = controller;
+    controller.registerCommand(
+      new GenerateTemplateCommand(controller._rawEditor._model)
+    );
+  }
+}

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

@@ -0,0 +1,16 @@
+export default class ImportSnippetPlugin {
+  controller;
+
+  get name() {
+    return 'import-snippet-plugin';
+  }
+
+  initialize(controller) {
+    this.controller = controller;
+    controller.registerWidget({
+      componentName: 'import-snippet-plugin/card',
+      identifier: 'import-snippet-plugin/card',
+      desiredLocation: 'sidebar',
+    });
+  }
+}

package/addon/plugins/insert-variable-plugin.js

@@ -0,0 +1,19 @@
+export default class InsertVariablePlugin {
+  controller;
+
+  get name() {
+    return 'insert-variable-plugin';
+  }
+
+  initialize(controller, options) {
+    this.controller = controller;
+    controller.registerWidget({
+      componentName: 'insert-variable-plugin/insert-variable-card',
+      identifier: 'insert-variable-plugin/card',
+      desiredLocation: 'sidebar',
+      widgetArgs: {
+        options: options,
+      },
+    });
+  }
+}

package/addon/plugins/rdfa-date-plugin.js

@@ -0,0 +1,26 @@
+import ModifyDateCommand from '../commands/modify-date-command';
+
+export default class RdfaDatePlugin {
+  controller;
+
+  get name() {
+    return 'rdfa-date-plugin';
+  }
+
+  initialize(controller) {
+    this.controller = controller;
+    controller.registerWidget({
+      componentName: 'rdfa-date-plugin/rdfa-date-plugin-card',
+      identifier: 'rdfa-date-plugin/card',
+      desiredLocation: 'sidebar',
+    });
+    controller.registerWidget({
+      componentName: 'rdfa-date-plugin/rdfa-date-plugin-insert',
+      identifier: 'rdfa-date-plugin/insert',
+      desiredLocation: 'insertSidebar',
+    });
+    controller.registerCommand(
+      new ModifyDateCommand(controller._rawEditor._model)
+    );
+  }
+}

package/addon/plugins/roadsign-regulation-plugin.js

@@ -0,0 +1,24 @@
+/**
+ * Entrypoint for the roadsign regulation plugin.
+ */
+export default class RoadSignRegulationPlugin {
+  controller;
+
+  get name() {
+    return 'roadsign-regulation-plugin';
+  }
+
+  /**
+   * Gets called when the editor loads.
+   * Can optionally be async if needed.
+   * @param controller
+   */
+  initialize(controller) {
+    this.controller = controller;
+    controller.registerWidget({
+      componentName: 'roadsign-regulation-plugin/roadsign-regulation-card',
+      identifier: 'roadsign-regulation-plugin/roadsign-regulation-card',
+      desiredLocation: 'insertSidebar',
+    });
+  }
+}