@lblod/ember-rdfa-editor-lblod-plugins 10.0.0 → 11.0.0

package/addon/plugins/variable-plugin/utils/address-helpers.ts

@@ -0,0 +1,112 @@
+import { Address, ResolvedAddress } from '../variables/address';
+
+type LocationRegisterResult = {
+  LocationResult: {
+    ID: number;
+    FormattedAddress: string;
+    Municipality: string;
+    Thoroughfarename: string; // street
+    Housenumber?: string | null;
+    Zipcode: string;
+    Location: {
+      Lat_WGS84: number;
+      Lon_WGS84: number;
+      X_Lambert72: number;
+      Y_Lambert72: number;
+    };
+  }[];
+};
+
+type AddressRegisterResult = {
+  adressen: {
+    identificator: {
+      id: string;
+      naamruimte: string;
+      objectId: string;
+      versieId: string;
+    };
+    detail: string;
+    huisnummer: string;
+    volledigAdres: {
+      geografischeNaam: {
+        spelling: string;
+        taal: string;
+      };
+    };
+    adresStatus: string;
+  }[];
+};
+
+const LOC_GEOPUNT_ENDPOINT = `https://geo.api.vlaanderen.be/geolocation/v4/Location`;
+const BASISREGISTER_ADRESMATCH = `https://basisregisters.vlaanderen.be/api/v1/adressen`;
+
+export const replaceAccents = (string: string) =>
+  string.normalize('NFD').replace(/([\u0300-\u036f])/g, '');
+
+export async function fetchAddresses(
+  query: string,
+  includeHousenumber = true,
+): Promise<Address[]> {
+  const url = new URL(LOC_GEOPUNT_ENDPOINT);
+  url.searchParams.append('q', replaceAccents(query.replace(/^"(.*)"$/, '$1')));
+  url.searchParams.append('c', '10');
+  url.searchParams.append(
+    'type',
+    includeHousenumber ? 'Housenumber' : 'Thoroughfarename',
+  );
+  const result = await fetch(url, {
+    method: 'GET',
+  });
+
+  if (result.ok) {
+    const jsonResult = (await result.json()) as LocationRegisterResult;
+    const addresses = jsonResult.LocationResult.map(
+      (entry) =>
+        new Address({
+          street: entry.Thoroughfarename,
+          housenumber: entry.Housenumber,
+          zipcode: entry.Zipcode,
+          municipality: entry.Municipality,
+          location: {
+            lat_WGS84: entry.Location.Lat_WGS84,
+            long_WGS84: entry.Location.Lon_WGS84,
+          },
+        }),
+    );
+    return addresses;
+  } else {
+    throw new Error(
+      'An error occured when querying the location register, status code: ${response.status}',
+    );
+  }
+}
+
+export async function resolveAddress(
+  address: Address,
+): Promise<ResolvedAddress> {
+  const url = new URL(BASISREGISTER_ADRESMATCH);
+
+  url.searchParams.append('GemeenteNaam', replaceAccents(address.municipality));
+  url.searchParams.append('Straatnaam', replaceAccents(address.street));
+  if (address.housenumber) {
+    url.searchParams.append('Huisnummer', replaceAccents(address.housenumber));
+  }
+  url.searchParams.append('Postcode', replaceAccents(address.zipcode));
+
+  const response = await fetch(url.toString(), {
+    method: 'GET',
+  });
+  if (response.ok) {
+    const result = (await response.json()) as AddressRegisterResult;
+    if (result.adressen.length) {
+      const addressRegisterId = result.adressen[0].identificator.id;
+      return ResolvedAddress.resolve(address, addressRegisterId);
+    } else {
+      throw new Error('Could not find address in address register');
+    }
+  } else {
+    throw new Error(
+      `An error occured when querying the address register, status code: ${response.status}`,
+    );
+  }
+}

package/addon/plugins/variable-plugin/variables/address.ts

@@ -0,0 +1,322 @@
+import {
+  ADRES,
+  EXT,
+  GEO,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/utils/constants';
+import {
+  createEmberNodeSpec,
+  createEmberNodeView,
+  EmberNodeConfig,
+} from '@lblod/ember-rdfa-editor/utils/ember-node';
+import { v4 as uuidv4 } from 'uuid';
+import { DOMOutputSpec, PNode } from '@lblod/ember-rdfa-editor';
+import {
+  isVariable,
+  parseLabel,
+  parseVariableInstance,
+  parseVariableType,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/variable-plugin/utils/attribute-parsers';
+import {
+  findChildWithRdfaAttribute,
+  hasRDFaAttribute,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/utils/namespace';
+import { span } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/dom-output-spec-helpers';
+import {
+  contentSpan,
+  instanceSpan,
+  mappingSpan,
+  typeSpan,
+} from '../utils/dom-constructors';
+
+type Location = {
+  lat_WGS84: number;
+  long_WGS84: number;
+};
+export class Address {
+  declare street: string;
+  declare zipcode: string;
+  declare municipality: string;
+  declare location: Location;
+  housenumber?: string | null;
+  constructor(
+    args: Pick<
+      Address,
+      'street' | 'housenumber' | 'zipcode' | 'municipality' | 'location'
+    >,
+  ) {
+    Object.assign(this, args);
+  }
+
+  get formatted() {
+    const firstPart = this.housenumber
+      ? `${this.street} ${this.housenumber}`
+      : this.street;
+    const secondPart = `${this.zipcode} ${this.municipality}`;
+    return `${firstPart}, ${secondPart}`;
+  }
+
+  sameAs(other?: Address | null) {
+    if (other) {
+      return (
+        this.street === other.street &&
+        this.housenumber === other.housenumber &&
+        this.zipcode === other.zipcode &&
+        this.municipality === other.municipality &&
+        this.location.lat_WGS84 === other.location.lat_WGS84 &&
+        this.location.long_WGS84 === other.location.long_WGS84
+      );
+    } else {
+      return false;
+    }
+  }
+
+  get hasHouseNumber() {
+    return !!this.housenumber;
+  }
+}
+
+export class ResolvedAddress extends Address {
+  addressRegisterId: string;
+
+  constructor(
+    args: Pick<
+      ResolvedAddress,
+      | 'street'
+      | 'housenumber'
+      | 'zipcode'
+      | 'municipality'
+      | 'addressRegisterId'
+      | 'location'
+    >,
+  ) {
+    super(args);
+    this.addressRegisterId = args.addressRegisterId;
+  }
+
+  static resolve(address: Address, addressRegisterId: string) {
+    return new ResolvedAddress({
+      addressRegisterId,
+      ...address,
+    });
+  }
+}
+
+const constructLocationNode = (location: Location) => {
+  return span(
+    {
+      property: ADRES('positie').full,
+      typeof: GEO('Point').full,
+    },
+    span({
+      property: GEO('lat').full,
+      content: location.lat_WGS84.toString(),
+    }),
+    span({
+      property: GEO('long').full,
+      content: location.long_WGS84.toString(),
+    }),
+  );
+};
+
+const constructAddressNode = (address?: Address | ResolvedAddress) => {
+  if (address) {
+    const resource =
+      'addressRegisterId' in address ? address.addressRegisterId : undefined;
+    const houseNumberSpan = address.housenumber
+      ? span(
+          {
+            property: ADRES('huisnummer').full,
+          },
+          address.housenumber,
+        )
+      : '';
+    return contentSpan(
+      { resource, typeof: ADRES('Adres').full },
+      span(
+        {
+          property: ADRES('heeftStraatnaam').full,
+        },
+        address.street,
+      ),
+      address.housenumber ? ' ' : '', //if there is still a housenumber coming after the street, insert a space.
+      houseNumberSpan,
+      ', ',
+      span(
+        {
+          property: ADRES('heeftPostinfo').full,
+          typeof: ADRES('Postinfo').full,
+        },
+        span(
+          {
+            property: ADRES('postcode').full,
+          },
+          address.zipcode,
+        ),
+      ),
+      ' ',
+      span(
+        {
+          property: ADRES('gemeentenaam').full,
+        },
+        address.municipality,
+      ),
+      constructLocationNode(address.location),
+    );
+  } else {
+    return contentSpan({}, 'Voeg adres in');
+  }
+};
+
+const parseLocationNode = (locationNode: Element): Location | undefined => {
+  const lat_WGS84 = findChildWithRdfaAttribute(
+    locationNode,
+    'property',
+    GEO('lat'),
+  )?.getAttribute('content');
+  const long_WGS84 = findChildWithRdfaAttribute(
+    locationNode,
+    'property',
+    GEO('long'),
+  )?.getAttribute('content');
+  if (lat_WGS84 && long_WGS84) {
+    const lat_WGS84_number = parseFloat(lat_WGS84);
+    const long_WGS84_number = parseFloat(long_WGS84);
+    if (!isNaN(lat_WGS84_number) && !isNaN(long_WGS84_number)) {
+      return {
+        lat_WGS84: lat_WGS84_number,
+        long_WGS84: long_WGS84_number,
+      };
+    }
+  }
+  return;
+};
+
+const parseAddressNode = (addressNode: Element): Address | undefined => {
+  const addressRegisterId = addressNode.getAttribute('resource');
+  const street = findChildWithRdfaAttribute(
+    addressNode,
+    'property',
+    ADRES('heeftStraatnaam'),
+  )?.textContent;
+  const housenumber = findChildWithRdfaAttribute(
+    addressNode,
+    'property',
+    ADRES('huisnummer'),
+  )?.textContent;
+  const postInfoNode = findChildWithRdfaAttribute(
+    addressNode,
+    'property',
+    ADRES('heeftPostinfo'),
+  );
+  const zipcode = postInfoNode
+    ? findChildWithRdfaAttribute(postInfoNode, 'property', ADRES('postcode'))
+        ?.textContent
+    : null;
+  const municipality = findChildWithRdfaAttribute(
+    addressNode,
+    'property',
+    ADRES('gemeentenaam'),
+  )?.textContent;
+  const locationNode = findChildWithRdfaAttribute(
+    addressNode,
+    'property',
+    ADRES('positie'),
+  );
+  const location = locationNode && parseLocationNode(locationNode);
+  if (street && zipcode && municipality && location) {
+    if (addressRegisterId) {
+      return new ResolvedAddress({
+        addressRegisterId,
+        street,
+        housenumber,
+        zipcode,
+        municipality,
+        location,
+      });
+    } else {
+      return new Address({
+        street,
+        housenumber,
+        zipcode,
+        municipality,
+        location,
+      });
+    }
+  } else {
+    return;
+  }
+};
+
+const parseDOM = [
+  {
+    tag: 'span',
+    getAttrs: (node: HTMLElement) => {
+      if (isVariable(node) && parseVariableType(node) === 'address') {
+        const mappingResource = node.getAttribute('resource');
+        if (!mappingResource) {
+          return false;
+        }
+        const variableInstance = parseVariableInstance(node);
+        const label = parseLabel(node);
+
+        const addressNode = [...node.children].find((el) =>
+          hasRDFaAttribute(el, 'property', EXT('content')),
+        );
+        if (!addressNode) {
+          return false;
+        }
+
+        return {
+          variableInstance:
+            variableInstance ?? `http://data.lblod.info/variables/${uuidv4()}`,
+          mappingResource,
+          label,
+          address: parseAddressNode(addressNode),
+        };
+      }
+
+      return false;
+    },
+  },
+];
+
+const toDOM = (node: PNode): DOMOutputSpec => {
+  const { mappingResource, variableInstance, label, address } = node.attrs;
+  return mappingSpan(
+    mappingResource,
+    {
+      'data-label': label as string,
+    },
+    instanceSpan(variableInstance),
+    typeSpan('address'),
+    constructAddressNode(address),
+  );
+};
+
+const emberNodeConfig: EmberNodeConfig = {
+  name: 'address',
+  componentPath: 'variable-plugin/address/nodeview',
+  inline: true,
+  group: 'inline variable',
+  content: 'inline*',
+  atom: true,
+  recreateUri: true,
+  uriAttributes: ['variableInstance'],
+  draggable: false,
+  needsFFKludge: true,
+  attrs: {
+    mappingResource: {},
+    variableInstance: {},
+    label: {
+      default: 'adres',
+    },
+    address: {
+      default: null,
+    },
+  },
+  toDOM,
+  parseDOM,
+};
+
+export const address = createEmberNodeSpec(emberNodeConfig);
+export const addressView = createEmberNodeView(emberNodeConfig);

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

@@ -2,3 +2,4 @@ export * from './number';
 export * from './text';
 export * from './codelist';
 export * from './location';
+export * from './address';

package/addon/plugins/variable-plugin/variables/text.ts

@@ -64,7 +64,7 @@ const toDOM = (node: PNode): DOMOutputSpec => {
   );
 };
 
-export const emberNodeConfig: EmberNodeConfig = {
+const emberNodeConfig: EmberNodeConfig = {
   name: 'text-variable',
   componentPath: 'variable-plugin/variable/nodeview',
   inline: true,

package/addon/utils/constants.ts

@@ -20,3 +20,10 @@ export const MOBILITEIT = namespace(
   'https://data.vlaanderen.be/ns/mobiliteit#',
   'mobiliteit',
 );
+
+export const ADRES = namespace('https://data.vlaanderen.be/ns/adres/', 'adres');
+export const GENERIEK = namespace(
+  'https://data.vlaanderen.be/ns/generiek/#',
+  'generiek',
+);
+export const GEO = namespace('http://www.w3.org/2003/01/geo/wgs84_pos#', 'geo');

package/addon/utils/namespace.ts

@@ -32,6 +32,17 @@ export function hasRDFaAttribute(
   return false;
 }
 
+export function findChildWithRdfaAttribute(
+  element: Element,
+  attr: string,
+  value: Resource,
+) {
+  return [...element.children].find((child) => {
+    const result = child.getAttribute(attr)?.split(' ');
+    return result?.includes(value.full) || result?.includes(value.prefixed);
+  });
+}
+
 export function pnodeHasRdfaAttribute(
   node: PNode,
   attr: string,

package/app/components/snippet-plugin/snippet-list/snippet-list-modal.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/snippet-plugin/snippet-list/snippet-list-modal';

package/app/components/snippet-plugin/snippet-list/snippet-list-view.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/snippet-plugin/snippet-list/snippet-list-view';

package/app/components/snippet-plugin/snippet-list-select.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/snippet-plugin/snippet-list-select';

package/app/components/{address-plugin/insert.js → variable-plugin/address/edit.js}

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/address-plugin/insert';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/variable-plugin/address/edit';

package/app/components/variable-plugin/address/insert.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/variable-plugin/address/insert';

package/app/components/variable-plugin/address/nodeview.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/variable-plugin/address/nodeview';

package/app/helpers/in-array.js

@@ -0,0 +1,4 @@
+export {
+  default,
+  inArray,
+} from '@lblod/ember-rdfa-editor-lblod-plugins/helpers/in-array';

package/app/styles/snippet-plugin.scss

@@ -70,3 +70,14 @@
     position: relative;
   }
 }
+
+.snippet-lists-table {
+  .au-c-table-wrapper {
+    margin-top: 20px;
+    margin-right: 100px;
+
+    .selectColumn {
+      width: 200px;
+    }
+  }
+}

package/components/snippet-plugin/search-modal.d.ts

@@ -2,6 +2,7 @@ import Component from '@glimmer/component';
 import { SnippetPluginConfig } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/snippet-plugin';
 interface Args {
     config: SnippetPluginConfig;
+    assignedSnippetListsIds: string[];
     closeModal: () => void;
 }
 export default class SnippetPluginSearchModalComponent extends Component<Args> {

package/components/snippet-plugin/snippet-insert.d.ts

@@ -4,6 +4,7 @@ import { SnippetPluginConfig } from '@lblod/ember-rdfa-editor-lblod-plugins/plug
 interface Args {
     controller: SayController;
     config: SnippetPluginConfig;
+    assignedSnippetListsIds: string[];
 }
 export default class SnippetInsertComponent extends Component<Args> {
     showModal: boolean;

package/components/snippet-plugin/snippet-list/snippet-list-modal.d.ts

@@ -0,0 +1,23 @@
+import Component from '@glimmer/component';
+import { Task } from 'ember-concurrency';
+import { SnippetPluginConfig, SnippetList } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/snippet-plugin';
+interface Args {
+    config: SnippetPluginConfig;
+    onSaveSnippetListIds: Task<Promise<void>, [snippetIds: string[]]>;
+    assignedSnippetListsIds: string[];
+    closeModal: () => void;
+}
+export default class SnippetListModalComponent extends Component<Args> {
+    inputSearchText: string | null;
+    error: unknown;
+    assignedSnippetListsIds: string[];
+    get config(): SnippetPluginConfig;
+    get searchText(): string | null;
+    setInputSearchText(event: InputEvent): void;
+    closeModal(): void;
+    saveAndClose(): Promise<void>;
+    snippetListSearch: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, () => Promise<SnippetList[]>>;
+    snippetListResource: import("ember-resources/util/ember-concurrency").TaskInstance<SnippetList[]>;
+    onChange(assignedSnippetListsIds: string[]): void;
+}
+export {};

package/components/snippet-plugin/snippet-list/snippet-list-view.d.ts

@@ -0,0 +1,10 @@
+import Component from '@glimmer/component';
+interface Args {
+    assignedSnippetListsIds: string[];
+    onChange: (assignedSnippetListsIds: string[]) => void;
+    closeModal: () => void;
+}
+export default class SnippetListViewComponent extends Component<Args> {
+    onChange(snippetId: string, isSelected: boolean): void;
+}
+export {};

package/components/snippet-plugin/snippet-list-select.d.ts

@@ -0,0 +1,14 @@
+import { Task } from 'ember-concurrency';
+import Component from '@glimmer/component';
+import { SnippetPluginConfig } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/snippet-plugin';
+interface Args {
+    config: SnippetPluginConfig;
+    assignedSnippetListsIds: string[];
+    onSaveSnippetListIds: Task<Promise<void>, [snippetIds: string[]]>;
+}
+export default class SnippetListSelectComponent extends Component<Args> {
+    showModal: boolean;
+    openModal(): void;
+    closeModal(): void;
+}
+export {};

package/components/table-of-contents-plugin/ember-nodes/table-of-contents.d.ts

@@ -1,24 +1,17 @@
 import Component from '@glimmer/component';
-import { PNode } from '@lblod/ember-rdfa-editor';
 import { EmberNodeArgs } from '@lblod/ember-rdfa-editor/utils/ember-node';
 import { TableOfContentsConfig } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/table-of-contents-plugin';
-type OutlineEntry = {
-    content: string;
-    pos: number;
-    children?: OutlineEntry[];
-};
+import IntlService from 'ember-intl/services/intl';
 export default class TableOfContentsComponent extends Component<EmberNodeArgs> {
+    intl: IntlService;
     get config(): TableOfContentsConfig;
+    get documentLanguage(): string;
+    get title(): string;
     get controller(): import("@lblod/ember-rdfa-editor").SayController;
     get outline(): {
-        entries: OutlineEntry[];
+        entries: import("@lblod/ember-rdfa-editor-lblod-plugins/plugins/table-of-contents-plugin/utils").OutlineEntry[];
     };
-    extractOutline({ node, pos }: {
-        node: PNode;
-        pos: number;
-    }): OutlineEntry[];
     moveToPosition(pos: number): void;
     getScrollContainer(): HTMLElement | undefined;
     isScrollable(element: HTMLElement): boolean;
 }
-export {};

package/components/variable-plugin/address/edit.d.ts

@@ -0,0 +1,23 @@
+import Component from '@glimmer/component';
+import { SayController } from '@lblod/ember-rdfa-editor';
+import { Address } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/variable-plugin/variables';
+type Args = {
+    controller: SayController;
+};
+export default class AddressEditComponent extends Component<Args> {
+    selectedAddress?: Address;
+    includeHouseNumber: boolean;
+    toggleIncludeHouseNumber(): void;
+    get currentAddress(): Address | null | undefined;
+    get selectedAddressVariable(): {
+        node: import("prosemirror-model").Node;
+        pos: number;
+    } | undefined;
+    get showCard(): boolean;
+    get canUpdate(): boolean;
+    updateAddressVariable: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, () => Promise<void>>;
+    selectAddress(address: Address): void;
+    get controller(): SayController;
+    searchAddress: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, (term: string) => Promise<Address[]>>;
+}
+export {};

package/components/variable-plugin/address/insert.d.ts

@@ -0,0 +1,11 @@
+import Component from '@glimmer/component';
+import { SayController } from '@lblod/ember-rdfa-editor';
+type Args = {
+    controller: SayController;
+};
+export default class InsertAddressComponent extends Component<Args> {
+    get controller(): SayController;
+    get schema(): import("prosemirror-model").Schema<any, any>;
+    insertAddress(): void;
+}
+export {};

package/components/variable-plugin/address/nodeview.d.ts

@@ -0,0 +1,14 @@
+import Component from '@glimmer/component';
+import { PNode, SayController } from '@lblod/ember-rdfa-editor';
+import { Address } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/variable-plugin/variables/address';
+type Args = {
+    getPos: () => number | undefined;
+    node: PNode;
+    controller: SayController;
+};
+export default class AddressNodeviewComponent extends Component<Args> {
+    get node(): PNode;
+    get address(): Address | null;
+    selectThisNode(): void;
+}
+export {};

package/components/variable-plugin/number/insert.d.ts

@@ -13,6 +13,8 @@ export default class NumberInsertComponent extends Component<Args> {
     get schema(): import("prosemirror-model").Schema<any, any>;
     get numberVariableError(): string;
     updateLabel(event: InputEvent): void;
+    updateMinimumValue(event: InputEvent): void;
+    updateMaximumValue(event: InputEvent): void;
     insert(): void;
 }
 export {};