chore: moving events, interfaces and types to @openscd/core (#1507)

* feat(core): extract api from open-scd (events, types and interfaces)
- places api into folder "foundation/deprecated"
- (does not include code related to wizards or scl library)

Signed-off-by: Juan Munoz <[email protected]>

* chore: adding exports for new foundation files
- duplicate entries without file extensions were necessary to overcome snowpack errors when building open-scd

Signed-off-by: Juan Munoz <[email protected]>

* chore: updating imports to new foundation files in @openscd/core

Signed-off-by: Juan Munoz <[email protected]>

* chore: updating package-lock

Signed-off-by: Juan Munoz <[email protected]>

* chore: updates package-lock

Signed-off-by: Juan Munoz <[email protected]>

---------

Signed-off-by: Juan Munoz <[email protected]>

Author: juancho0202

package-lock.json

@@ -0,0 +1,174 @@
+/** Inserts `new.element` to `new.parent` before `new.reference`. */
+export interface Create {
+  new: { parent: Node; element: Node; reference?: Node | null };
+  derived?: boolean;
+  checkValidity?: () => boolean;
+}
+/** Removes `old.element` from `old.parent` before `old.reference`. */
+export interface Delete {
+  old: { parent: Node; element: Node; reference?: Node | null };
+  derived?: boolean;
+  checkValidity?: () => boolean;
+}
+/** Reparents of `old.element` to `new.parent` before `new.reference`. */
+export interface Move {
+  old: { parent: Element; element: Element; reference?: Node | null };
+  new: { parent: Element; reference?: Node | null };
+  derived?: boolean;
+  checkValidity?: () => boolean;
+}
+/** Replaces `old.element` with `new.element`, keeping element children. */
+export interface Replace {
+  old: { element: Element };
+  new: { element: Element };
+  derived?: boolean;
+  checkValidity?: () => boolean;
+}
+/** Swaps `element`s `oldAttributes` with `newAttributes` */
+export interface Update {
+  element: Element;
+  oldAttributes: Record<string, string | null>;
+  newAttributes: Record<string, string | null>;
+  derived?: boolean;
+  checkValidity?: () => boolean;
+}
+
+export type SimpleAction = Update | Create | Replace | Delete | Move;
+export type ComplexAction = {
+  actions: SimpleAction[];
+  title: string;
+  derived?: boolean;
+};
+/** Represents an intended or committed change to some `Element`. */
+export type EditorAction = SimpleAction | ComplexAction;
+
+export function isCreate(action: EditorAction): action is Create {
+  return (
+    (action as Replace).old === undefined &&
+    (action as Create).new?.parent !== undefined &&
+    (action as Create).new?.element !== undefined
+  );
+}
+export function isDelete(action: EditorAction): action is Delete {
+  return (
+    (action as Delete).old?.parent !== undefined &&
+    (action as Delete).old?.element !== undefined &&
+    (action as Replace).new === undefined
+  );
+}
+export function isMove(action: EditorAction): action is Move {
+  return (
+    (action as Move).old?.parent !== undefined &&
+    (action as Move).old?.element !== undefined &&
+    (action as Move).new?.parent !== undefined &&
+    (action as Replace).new?.element == undefined
+  );
+}
+export function isReplace(action: EditorAction): action is Replace {
+  return (
+    (action as Move).old?.parent === undefined &&
+    (action as Replace).old?.element !== undefined &&
+    (action as Move).new?.parent === undefined &&
+    (action as Replace).new?.element !== undefined
+  );
+}
+export function isUpdate(action: EditorAction): action is Update {
+  return (
+    (action as Replace).old === undefined &&
+    (action as Replace).new === undefined &&
+    (action as Update).element !== undefined &&
+    (action as Update).newAttributes !== undefined &&
+    (action as Update).oldAttributes !== undefined
+  );
+}
+export function isSimple(action: EditorAction): action is SimpleAction {
+  return !((<ComplexAction>action).actions instanceof Array);
+}
+
+//** return `Update` action for `element` adding `oldAttributes` */
+export function createUpdateAction(
+  element: Element,
+  newAttributes: Record<string, string | null>
+): Update {
+  const oldAttributes: Record<string, string | null> = {};
+  Array.from(element.attributes).forEach(attr => {
+    oldAttributes[attr.name] = attr.value;
+  });
+
+  return { element, oldAttributes, newAttributes };
+}
+
+/** Throws an error bearing `message`, never returning. */
+export function unreachable(message: string): never {
+  throw new Error(message);
+}
+
+/** @returns an [[`EditorAction`]] with opposite effect of `action`. */
+export function invert(action: EditorAction): EditorAction {
+  if (!isSimple(action)) {
+    const inverse: ComplexAction = {
+      title: action.title,
+      derived: action.derived,
+      actions: [],
+    };
+    action.actions.forEach(element =>
+      inverse.actions.unshift(<SimpleAction>invert(element))
+    );
+    return inverse;
+  }
+
+  const metaData = {
+    derived: action.derived,
+    checkValidity: action.checkValidity,
+  };
+  if (isCreate(action)) return { old: action.new, ...metaData };
+  else if (isDelete(action)) return { new: action.old, ...metaData };
+  else if (isMove(action))
+    return {
+      old: {
+        parent: action.new.parent,
+        element: action.old.element,
+        reference: action.new.reference,
+      },
+      new: { parent: action.old.parent, reference: action.old.reference },
+      ...metaData,
+    };
+  else if (isReplace(action))
+    return { new: action.old, old: action.new, ...metaData };
+  else if (isUpdate(action))
+    return {
+      element: action.element,
+      oldAttributes: action.newAttributes,
+      newAttributes: action.oldAttributes,
+      ...metaData,
+    };
+  else return unreachable('Unknown EditorAction type in invert.');
+}
+
+/** Represents some intended modification of a `Document` being edited. */
+export interface EditorActionDetail<T extends EditorAction> {
+  action: T;
+}
+export type EditorActionEvent<T extends EditorAction> = CustomEvent<
+  EditorActionDetail<T>
+>;
+
+export function newActionEvent<T extends EditorAction>(
+  action: T,
+  eventInitDict?: CustomEventInit<Partial<EditorActionDetail<T>>>
+): EditorActionEvent<T> {
+  return new CustomEvent<EditorActionDetail<T>>('editor-action', {
+    bubbles: true,
+    composed: true,
+    ...eventInitDict,
+    detail: { action, ...eventInitDict?.detail },
+  });
+}
+
+
+declare global {
+    interface ElementEventMap {
+      ['editor-action']: EditorActionEvent<EditorAction>;
+    }
+  }
+  

packages/core/foundation/deprecated/editor.ts

@@ -0,0 +1,77 @@
+import { EditorAction } from './editor';
+
+type InfoEntryKind = 'info' | 'warning' | 'error';
+
+export type LogEntryType = 'info' | 'warning' | 'error' | 'action' | 'reset';
+
+/** The basic information contained in each [[`LogEntry`]]. */
+export interface LogDetailBase {
+  title: string;
+  message?: string;
+}
+/** The [[`LogEntry`]] for a committed [[`EditorAction`]]. */
+export interface CommitDetail extends LogDetailBase {
+  kind: 'action';
+  action: EditorAction;
+}
+/** A [[`LogEntry`]] for notifying the user. */
+export interface InfoDetail extends LogDetailBase {
+  kind: InfoEntryKind;
+  cause?: LogEntry;
+}
+
+export interface ResetDetail {
+  kind: 'reset';
+}
+
+export type LogDetail = InfoDetail | CommitDetail | ResetDetail;
+export type LogEvent = CustomEvent<LogDetail>;
+
+export interface IssueDetail extends LogDetailBase {
+  validatorId: string;
+  element?: Element;
+}
+export type IssueEvent = CustomEvent<IssueDetail>;
+
+/** [[`LogEntry`]]s are timestamped upon being committed to the `history`. */
+interface Timestamped {
+  time: Date | null;
+}
+
+export type CommitEntry = Timestamped & CommitDetail;
+export type InfoEntry = Timestamped & InfoDetail;
+
+export type LogEntry = InfoEntry | CommitEntry;
+
+
+export function newLogEvent(
+  detail: LogDetail,
+  eventInitDict?: CustomEventInit<LogDetail>
+): LogEvent {
+  return new CustomEvent<LogDetail>('log', {
+    bubbles: true,
+    composed: true,
+    ...eventInitDict,
+    detail: { ...detail, ...eventInitDict?.detail },
+  });
+}
+
+export function newIssueEvent(
+  detail: IssueDetail,
+  eventInitDict?: CustomEventInit<IssueDetail>
+): IssueEvent {
+  return new CustomEvent<IssueDetail>('issue', {
+    bubbles: true,
+    composed: true,
+    ...eventInitDict,
+    detail: { ...detail, ...eventInitDict?.detail },
+  });
+}
+
+declare global {
+    interface ElementEventMap {
+      ['log']: LogEvent;
+      ['issue']: IssueEvent;
+    }
+  }
+  

packages/core/foundation/deprecated/history.ts

@@ -0,0 +1,25 @@
+/** Represents a document to be opened. */
+export interface OpenDocDetail {
+  doc: XMLDocument;
+  docName: string;
+  docId?: string;
+}
+export type OpenDocEvent = CustomEvent<OpenDocDetail>;
+export function newOpenDocEvent(
+  doc: XMLDocument,
+  docName: string,
+  eventInitDict?: CustomEventInit<Partial<OpenDocDetail>>
+): OpenDocEvent {
+  return new CustomEvent<OpenDocDetail>('open-doc', {
+    bubbles: true,
+    composed: true,
+    ...eventInitDict,
+    detail: { doc, docName, ...eventInitDict?.detail },
+  });
+}
+
+declare global {
+    interface ElementEventMap {
+      ['open-doc']: OpenDocEvent;
+    }
+  }

packages/core/foundation/deprecated/open-event.ts

@@ -0,0 +1,70 @@
+export type Language = 'en' | 'de';
+
+export type Settings = {
+  language: Language;
+  theme: 'light' | 'dark';
+  mode: 'safe' | 'pro';
+  showieds: 'on' | 'off';
+  'IEC 61850-7-2': string | undefined;
+  'IEC 61850-7-3': string | undefined;
+  'IEC 61850-7-4': string | undefined;
+  'IEC 61850-8-1': string | undefined;
+};
+
+export type NsdVersion = {
+  version: string | undefined;
+  revision: string | undefined;
+  release: string | undefined;
+};
+
+export type NsdVersions = {
+  'IEC 61850-7-2': NsdVersion;
+  'IEC 61850-7-3': NsdVersion;
+  'IEC 61850-7-4': NsdVersion;
+  'IEC 61850-8-1': NsdVersion;
+};
+
+/** Represents a document to be opened. */
+export interface LoadNsdocDetail {
+  nsdoc: string;
+  filename: string;
+}
+export type LoadNsdocEvent = CustomEvent<LoadNsdocDetail>;
+export function newLoadNsdocEvent(
+  nsdoc: string,
+  filename: string
+): LoadNsdocEvent {
+  return new CustomEvent<LoadNsdocDetail>('load-nsdoc', {
+    bubbles: true,
+    composed: true,
+    detail: { nsdoc, filename },
+  });
+}
+
+export interface SettingsUIDetail {
+  show: boolean;
+}
+
+export type SettingsUIEvent = CustomEvent<SettingsUIDetail>;
+
+export function newSettingsUIEvent(
+  show: boolean,
+  eventInitDict?: CustomEventInit<Partial<SettingsUIDetail>>
+): SettingsUIEvent {
+  return new CustomEvent<SettingsUIDetail>('oscd-settings', {
+    bubbles: true,
+    composed: true,
+    ...eventInitDict,
+    detail: {
+      show,
+      ...eventInitDict?.detail,
+    },
+  });
+}
+
+
+declare global {
+  interface ElementEventMap {
+    ['oscd-settings']: SettingsUIEvent;
+  }
+}

packages/core/foundation/deprecated/settings.ts

@@ -0,0 +1,19 @@
+/** Represents a request for validation. */
+export type ValidateEvent = CustomEvent<void>;
+export function newValidateEvent(
+  eventInitDict?: CustomEventInit<void>
+): ValidateEvent {
+  return new CustomEvent<void>('validate', {
+    bubbles: true,
+    composed: true,
+    ...eventInitDict,
+  });
+}
+
+
+declare global {
+    interface ElementEventMap {
+      ['validate']: ValidateEvent;
+    }
+  }
+