@datapos/datapos-shared 0.1.867

package/LICENSE.md

@@ -0,0 +1,7 @@
+ISC License (ISC)
+
+Copyright 2013 Jonathan Terrell
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# Datapos - Core Share Library
+
+A TypeScript library of core declarations and utilities shared between Datapos applications and plugin components.
+
+## Installation
+
+```
+npm install --save-dev @datapos-shared
+```
+
+## Component Configuration Declarations
+
+The following diagram illustrates the component configuration class hierarchy, showcasing the relationships and inheritance structure between different **Component Configuration** classes.
+
+## Component Instance Declarations
+
+The following diagram illustrates the component class hierarchy, showcasing the relationships and inheritance structure between different **Component** classes.
+
+## Connector Configuration Declarations
+
+The following diagram illustrates the connector class hierarchies, showcasing the relationships and inheritance structure between different **Connector Configuration** classes and detailing referenced enumeration types.
+
+## Data Connector Instance Declarations
+
+The following diagram illustrates the connector class hierarchies, showcasing the relationships and inheritance structure between different **Data Connector** classes and detailing referenced enumeration types.
+
+## Node Connector Instance Declarations
+
+The following diagram illustrates the connector class hierarchies, showcasing the relationships and inheritance structure between different **Node Connector** classes and detailing referenced enumeration types.
+
+## Connection Declarations
+
+The following diagram illustrates the connection class hierarchy, showcasing the relationships and inheritance structure between different **Connection** classes and detailing referenced enumeration types.
+
+## Connection Entry Declarations
+
+The following diagram illustrates the connection entry class hierarchy, showcasing the relationships and inheritance structure between different **Connection Entry** classes and detailing referenced enumeration types.
+
+## Context Model Declarations
+
+...
+
+## Data View Declarations
+
+...
+
+## Dimension Declarations
+
+...
+
+## Entity Declarations
+
+...
+
+## Event Query Declarations
+
+...
+
+## Usage Kit Declarations
+
+...
+
+## View Template Declarations
+
+...
+
+## Other Declarations
+
+...
+
+## Utilities
+
+### Conversion
+
+-   convertODataTypeToDataType
+
+### Extraction
+
+-   extractDirectoryPathFromEntryPath
+-   extractExtensionFromEntryPath
+-   extractLastFolderNameFromFolderPath
+
+### Formatting
+
+-   formatNumberAsDecimalNumber
+-   formatNumberAsStorageSize
+-   formatNumberAsWholeNumber
+
+### Lookup
+
+-   lookupMimeTypeForFileExtension
+
+### Security
+
+-   establishVendorAccessToken
+
+## Repository Management Commands
+
+The following list details the repository management commands implementation by this project. For more details, please refer to the scripts section of the 'package.json' file in this project.
+
+| Name               | Key Code         | Notes                                                                                                                                                                                                       |
+| ------------------ | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| audit              | alt+ctrl+shift+a | Audit the project's dependencies for known security vulnerabilities.                                                                                                                                        |
+| build              | alt+ctrl+shift+b | Build the package using Vite build.                                                                                                                                                                         |
+| check              | alt+ctrl+shift+c | List the dependencies in the project that are outdated.                                                                                                                                                     |
+| document           | alt+ctrl+shift+d | Identify the licenses of the project's dependencies.                                                                                                                                                        |
+| format             | alt+ctrl+shift+f | NOT implemented.                                                                                                                                                                                            |
+| lint               | alt+ctrl+shift+l | Check the code for potential errors and enforces coding styles.                                                                                                                                             |
+| publishToNPM       | alt+ctrl+shift+n | Publishes the package to the [npm](https://www.npmjs.com/) registry. This action will publish the last synchronised version. Use the command line command 'npm publish' when publishing for the first time. |
+| release            | alt+ctrl+shift+r | Synchronise the local repository with the main GitHub repository and publish the package to the [npm](https://www.npmjs.com/) registry.                                                                     |
+| syncWithGitHub     | alt+ctrl+shift+s | Synchronise the local repository with the main GitHub repository.                                                                                                                                           |
+| test               | alt+ctrl+shift+l | NOT implemented.                                                                                                                                                                                            |
+| updateDependencies | alt+ctrl+shift+l | Install the latest version of outdated Data Position package dependencies.                                                                                                                                  |

package/dist/datapos-shared.es.js

@@ -0,0 +1,255 @@
+const x = 0, h = (e) => e, w = () => Date.now();
+class d extends Error {
+  locator;
+  constructor(t, n, r) {
+    super(t, r), this.name = "DataPosError", this.locator = n, Error.captureStackTrace?.(this, new.target);
+  }
+}
+class i extends d {
+  constructor(t, n, r) {
+    super(t, n, r), this.name = "ApplicationError";
+  }
+}
+class N extends i {
+  constructor(t, n, r) {
+    super(t, n, r), this.name = "APIError";
+  }
+}
+class S extends i {
+  constructor(t, n, r) {
+    super(t, n, r), this.name = "EngineError";
+  }
+}
+class u extends i {
+  body;
+  constructor(t, n, r, a) {
+    super(t, n, a), this.name = "FetchError", this.body = r;
+  }
+}
+class f extends i {
+  componentName;
+  info;
+  constructor(t, n, r, a, s) {
+    super(t, n, s), this.name = "VueHandledError", this.info = r, this.componentName = a;
+  }
+}
+class y extends i {
+  constructor(t, n, r) {
+    super(t, n, r), this.name = "WindowHandledRuntimeError";
+  }
+}
+class D extends i {
+  constructor(t, n, r) {
+    super(t, n, r), this.name = "WindowHandledPromiseRejectionError";
+  }
+}
+class $ extends d {
+  constructor(t, n, r) {
+    super(t, n, r), this.name = "OperationalError";
+  }
+}
+async function v(e, t, n) {
+  const r = `${t} Response status '${e.status}${e.statusText ? ` - ${e.statusText}` : ""}' received.`, a = await e.text();
+  return new u(r, n, a);
+}
+function T(e) {
+  return e.map((t) => t.message).join(" ");
+}
+function I(e, t = "Unknown error.") {
+  if (e instanceof Error) return e;
+  if (typeof e == "string") return new Error(e);
+  try {
+    return new Error(JSON.stringify(e ?? t));
+  } catch {
+    return new Error(t);
+  }
+}
+function F(e) {
+  const t = /* @__PURE__ */ new Set(), n = [];
+  let r = e;
+  for (; r && !t.has(r); ) {
+    t.add(r);
+    let a;
+    if (r instanceof u)
+      a = { body: r.body, locator: r.locator, message: r.message, name: r.name, stack: r.stack }, r = r.cause;
+    else if (r instanceof f)
+      a = { componentName: r.componentName, info: r.info, locator: r.locator, message: r.message, name: r.name, stack: r.stack }, r = r.cause;
+    else if (r instanceof d)
+      a = { locator: r.locator, message: r.message, name: r.name, stack: r.stack }, r = r.cause;
+    else if (r instanceof Error) {
+      const s = r;
+      a = { locator: "", message: s.message, name: s.name, stack: s.stack }, r = s.cause;
+    } else r ? (a = { locator: "", message: String(r), name: "Error" }, r = void 0) : (a = { locator: "", message: "Unknown error.", name: "Error" }, r = void 0);
+    /(?:\.{3}|[.!?])$/.test(a.message) || (a.message += "."), n.push(a);
+  }
+  return n;
+}
+const m = "en-US", l = {}, k = (e) => {
+  switch (e) {
+    case "Edm.Binary":
+      return "unknown";
+    // Binary...
+    case "Edm.Boolean":
+      return "boolean";
+    case "Edm.Byte":
+      return "wholeNumber";
+    case "Edm.DateTime":
+      return "moment";
+    // DateTime...
+    case "Edm.DateTimeOffset":
+      return "moment";
+    // DateTimeOffset...
+    case "Edm.Decimal":
+      return "decimalNumber";
+    case "Edm.Double":
+      return "decimalNumber";
+    case "Edm.Guid":
+      return "string";
+    case "Edm.Int16":
+      return "wholeNumber";
+    case "Edm.Int32":
+      return "wholeNumber";
+    case "Edm.Int64":
+      return "wholeNumber";
+    case "Edm.SByte":
+      return "wholeNumber";
+    case "Edm.Single":
+      return "decimalNumber";
+    case "Edm.String":
+      return "string";
+    case "Edm.Time":
+      return "momentTime";
+    // Time...
+    default:
+      return "unknown";
+  }
+}, A = (e) => {
+  if (e) {
+    const t = e.lastIndexOf("/"), n = e.lastIndexOf(".", t > -1 ? t : e.length);
+    return n > -1 ? e.substring(0, n) : e;
+  }
+}, B = (e) => {
+  if (e) {
+    const t = e.lastIndexOf(".");
+    if (t > -1) return e.substring(t + 1);
+  }
+}, o = (e, t = 2, n = t, r = m) => {
+  if (e == null) return "";
+  const a = `${r}decimal${t}.${n}`;
+  let s = l[a];
+  return s || (s = new Intl.NumberFormat(r, {
+    localeMatcher: "best fit",
+    maximumFractionDigits: t,
+    minimumFractionDigits: n,
+    minimumIntegerDigits: 1,
+    style: "decimal",
+    useGrouping: !0
+  }), l[a] = s), s.format(e);
+}, M = (e) => e == null ? "" : e < 1e3 ? c(e) : e < 1e6 ? `${o(e / 1e3, 2, 0)}K` : e < 1e9 ? `${o(e / 1e6, 2, 0)}M` : e < 1e12 ? `${o(e / 1e9, 2, 0)}B` : `${o(e / 1e12, 2, 0)}T`, R = (e) => e == null ? "" : e === 1 ? "1 byte" : e < 1024 ? `${c(e)} bytes` : e < 1048576 ? `${o(e / 1024, 2, 0)} KB` : e < 1073741824 ? `${o(e / 1048576, 2, 0)} MB` : e < 1099511627776 ? `${o(e / 1073741824, 2, 0)} GB` : `${o(e / 1099511627776, 2, 0)} TB`, O = (e) => e == null ? "" : e < 1e3 ? `${c(e)} ms` : e === 1e3 ? `${c(e)} sec` : e < 6e4 ? `${o(e / 1e3, 2, 0)} secs` : e === 6e4 ? "1 min" : e < 36e5 ? `${o(e / 6e4, 2, 0)} mins` : e === 36e5 ? "1 hr" : e < 864e5 ? `${o(e / 36e5, 2, 0)} hrs` : e === 864e5 ? "1 day" : `${o(e / 864e5, 2, 0)} days`, c = (e, t = m) => {
+  if (e == null) return "";
+  const n = `${t}decimal0.0`;
+  let r = l[n];
+  return r || (r = new Intl.NumberFormat(t, {
+    localeMatcher: "best fit",
+    maximumFractionDigits: 0,
+    minimumFractionDigits: 0,
+    minimumIntegerDigits: 1,
+    style: "decimal",
+    useGrouping: !0
+  }), l[n] = r), r.format(e);
+}, C = (e) => {
+  switch (e) {
+    case "csv":
+      return "text/csv";
+    case "tab":
+    case "tsv":
+      return "text/tab-separated-values";
+    case "xls":
+      return "application/vnd.ms-excel";
+    case "xlsx":
+      return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    default:
+      return "application/octet-stream";
+  }
+}, p = [
+  { id: "dtv", label: { en: "Delimited Text" } },
+  { id: "e/e", label: { en: "Entity/Event" } },
+  { id: "jsonArray", label: { en: "JSON Array" } },
+  { id: "spss", label: { en: "SPSS" } },
+  { id: "xls", label: { en: "XLS" } },
+  { id: "xlsx", label: { en: "XLSX" } },
+  { id: "xml", label: { en: "XML" } }
+], U = (e = "en") => {
+  const t = [];
+  for (const n of p) t.push({ ...n, label: n.label[e] || n.label.en || n.id });
+  return t;
+}, E = [
+  { id: `
+`, label: { en: "Newline" } },
+  { id: "\r", label: { en: "Carriage Return" } },
+  { id: `\r
+`, label: { en: "Carriage Return/Newline" } }
+], W = (e = "en") => {
+  const t = [];
+  for (const n of E) t.push({ ...n, label: n.label[e] || n.label.en || n.id });
+  return t;
+}, b = [
+  { id: ":", label: { en: "Colon" } },
+  { id: ",", label: { en: "Comma" } },
+  { id: "!", label: { en: "Exclamation Mark" } },
+  // { id: '', label: { en: 'Other' } }, // TODO: Maybe set this to a 'not printing' or special ascii character when there is a user supplied delimited, rather than ''?
+  { id: "0x1E", label: { en: "Record Separator" } },
+  { id: ";", label: { en: "Semicolon" } },
+  { id: " ", label: { en: "Space" } },
+  { id: "	", label: { en: "Tab" } },
+  { id: "_", label: { en: "Underscore" } },
+  { id: "0x1F", label: { en: "Unit Separator" } },
+  { id: "|", label: { en: "Vertical Bar" } }
+], j = (e = "en") => {
+  const t = [];
+  for (const n of b) t.push({ ...n, label: n.label[e] || n.label.en || n.id });
+  return t;
+}, g = [
+  { id: "alpha", color: "#d62728", label: { en: "alpha" } },
+  { id: "beta", color: "#8c564b", label: { en: "beta" } },
+  { id: "generalAvailability", label: { en: "" } },
+  { id: "notApplicable", label: { en: "not-applicable" } },
+  { id: "preAlpha", color: "#d62728", label: { en: "pre-alpha" } },
+  { id: "proposed", color: "#666666", label: { en: "proposed" } },
+  { id: "releaseCandidate", color: "#ff7f0e", label: { en: "release-candidate" } },
+  { id: "unavailable", color: "#d62728", label: { en: "unavailable" } },
+  { id: "underReview", color: "#666666", label: { en: "under-review" } }
+], G = (e, t = "en") => {
+  const n = g.find((r) => r.id === e);
+  return n ? { ...n, label: n.label[t] || n.label.en || e } : { id: e, color: "#d62728", label: e };
+};
+export {
+  N as APIError,
+  i as ApplicationError,
+  x as DefaultTimestamp,
+  S as EngineError,
+  u as FetchError,
+  $ as OperationalError,
+  f as VueError,
+  D as WindowPromiseRejectionError,
+  y as WindowRuntimeError,
+  v as buildFetchError,
+  T as concatenateSerialisedErrorMessages,
+  h as convertMillisecondsToTimestamp,
+  k as convertODataTypeIdToUsageTypeId,
+  B as extractExtensionFromPath,
+  A as extractNameFromPath,
+  o as formatNumberAsDecimalNumber,
+  O as formatNumberAsDuration,
+  M as formatNumberAsSize,
+  R as formatNumberAsStorageSize,
+  c as formatNumberAsWholeNumber,
+  G as getComponentStatus,
+  w as getCurrentTimestamp,
+  U as getDataFormats,
+  W as getRecordDelimiters,
+  j as getValueDelimiters,
+  C as lookupMimeTypeForExtension,
+  I as normalizeToError,
+  F as serialiseError
+};

package/dist/types/src/Z_ContentAuditColumn.d.ts

@@ -0,0 +1,33 @@
+import { PreviewColumn } from './Z_PreviewColumn';
+export type ParsedValue = {
+    isValid: boolean;
+    value: bigint | boolean | number | string | null;
+};
+export declare class ContentAuditColumn extends PreviewColumn {
+    doCountIndividualValidValues: boolean;
+    doCountPatterns: boolean;
+    invalidValueCount: number;
+    invalidValues: {
+        recordNumber: number;
+        value: string;
+    }[];
+    isRequired: boolean;
+    isUnique: boolean;
+    maxDecimals: number;
+    maxSize: number;
+    maxValue: boolean | number | string | undefined;
+    minDecimals: number;
+    minSize: number;
+    minValue: boolean | number | string | undefined;
+    patterns: Record<string, number>;
+    validValueCount: number;
+    validValues: Record<string, number>;
+    voidValueCount: number;
+    constructor(dataUsageTypeId: string, label: string);
+    addInvalidValue(originalValue: string, recordNumber: number): string;
+    addValidValue(originalValue: string, parsedValue: ParsedValue, wholeDigitCount?: number, decimalDigitCount?: number): ParsedValue;
+    addVoidValue(): null;
+    finalise(): void;
+    private determineNumericPattern;
+    private determineTextPattern;
+}

package/dist/types/src/Z_PreviewColumn.d.ts

@@ -0,0 +1,5 @@
+export declare class PreviewColumn {
+    dataUsageTypeId: string;
+    label: string;
+    constructor(dataUsageTypeId: string, label: string);
+}

package/dist/types/src/component.d.ts

@@ -0,0 +1,18 @@
+import { Timestamp } from './timestamp';
+export interface ComponentConfig extends Record<string, unknown> {
+    description?: Record<string, string>;
+    firstCreatedAt?: Timestamp;
+    id: string;
+    label: Record<string, string>;
+    lastUpdatedAt?: Timestamp;
+    logo?: string;
+    status?: ComponentStatus;
+    statusId: 'alpha' | 'beta' | 'generalAvailability' | 'notApplicable' | 'preAlpha' | 'proposed' | 'releaseCandidate' | 'unavailable' | 'underReview';
+    typeId: 'connection' | 'connector' | 'focus' | 'model' | 'dataView' | 'eventQuery' | 'presentation' | 'presenter' | 'tutorial';
+}
+export type ComponentStatus = {
+    id: string;
+    color?: string;
+    label: string;
+};
+export declare const getComponentStatus: (id: string, localeId?: string) => ComponentStatus;

package/dist/types/src/connection.d.ts

@@ -0,0 +1,73 @@
+import { ComponentConfig } from './component';
+import { ConnectorConfig } from './connector';
+import { Timestamp } from './timestamp';
+export interface ConnectionAuthorizationConfig {
+    accessToken: string;
+    accountId: string;
+    expiresAt: Timestamp;
+    expiresIn: number;
+    refreshToken: string;
+    scope: string;
+    tokenType: string;
+    uid: string;
+}
+export interface ConnectionConfig extends ComponentConfig {
+    authorisation: Record<string, ConnectionAuthorizationConfig>;
+    connectorConfig: ConnectorConfig;
+    lastVerifiedAt: Timestamp;
+    notation?: string;
+}
+export interface ConnectionNodeConfig {
+    childCount?: number;
+    columnsConfigs?: ConnectionColumnConfig[];
+    extension?: string;
+    folderPath: string;
+    handle?: DPAFileSystemFileHandle;
+    id: string;
+    nodeDisplayHeight?: number;
+    nodes?: ConnectionNodeConfig[];
+    label: string;
+    lastModifiedAt?: Timestamp;
+    mimeType?: string;
+    name: string;
+    size?: number;
+    typeId: ConnectionNodeTypeId;
+}
+export type ConnectionNodeTypeId = 'folder' | 'object';
+export interface ConnectionDescription {
+    objects: {
+        id: string;
+        label: Record<string, string>;
+        columns: ConnectionColumnConfig[];
+    }[];
+}
+export interface ConnectionColumnConfig {
+    invalidValueCount?: number;
+    invalidValues?: string[];
+    isIgnored?: boolean;
+    isRequired?: boolean;
+    isUnique?: boolean;
+    label: Record<string, string>;
+    maxDecimals?: number;
+    maxSize?: number;
+    maxValue?: string;
+    minDecimals?: number;
+    minSize?: number;
+    minValue?: string;
+    patterns?: Record<string, string>;
+    storageTypeId?: StorageTypeId;
+    usageTypeId?: UsageTypeId;
+    validValueCount?: number;
+    validValues?: Record<string, string>;
+    voidValueCount?: number;
+}
+export type DPAFileSystemFileHandle = {
+    readonly kind: 'file';
+    getFile(): Promise<File>;
+};
+export type StorageTypeId = 'binary' | 'boolean' | 'byte' | 'date' | 'dateTime' | 'dateTimeOffset' | 'decimal' | 'double' | 'int8' | 'int16' | 'int32' | 'int64' | 'object' | 'single' | 'string' | 'time' | 'unknown';
+export type UsageTypeId = 'boolean' | 'decimalNumber' | 'moment' | 'momentDate' | 'momentTime' | 'string' | 'unknown' | 'wholeNumber';
+export interface Encoding {
+    id: string;
+    confidenceLevel?: number;
+}

package/dist/types/src/connector.d.ts

@@ -0,0 +1,142 @@
+import { Callback, Options, Parser } from 'csv-parse/browser/esm';
+import { ComponentConfig } from './component';
+import { ConnectionConfig, ConnectionDescription, ConnectionNodeConfig } from './connection';
+import { DataViewContentAuditConfig, ValueDelimiterId } from './dataView';
+export interface Connector {
+    abortController?: AbortController | undefined;
+    readonly config: ConnectorConfig;
+    readonly connectionConfig: ConnectionConfig;
+    abortOperation?(connector: Connector): void;
+    authenticateConnection?(accountId: string, windowCenterX: number, windowCenterY: number): Window;
+    createObject?(connector: Connector, settings: CreateSettings): Promise<void>;
+    describeConnection?(connector: Connector, settings: DescribeSettings): Promise<DescribeResult>;
+    dropObject?(connector: Connector, settings: DropSettings): Promise<void>;
+    findObject?(connector: Connector, findSettings: FindSettings): Promise<FindResult>;
+    getRecord?(connector: Connector, getSettings: GetSettings): Promise<GetResult>;
+    listNodes?(connector: Connector, settings: ListSettings): Promise<ListResult>;
+    previewObject?(connector: Connector, settings: PreviewSettings): Promise<PreviewResult>;
+    removeRecords?(connector: Connector, settings: RemoveSettings): Promise<void>;
+    retrieveRecords?(connector: Connector, settings: RetrieveSettings, chunk: (records: (string[] | Record<string, unknown>)[]) => void, complete: (result: RetrieveSummary) => void, tools?: RetrieveTools): Promise<void>;
+    upsertRecords?(connector: Connector, settings: UpsertSettings): Promise<void>;
+}
+export interface ConnectorCallbackData {
+    typeId: string;
+    properties: Record<string, unknown>;
+}
+export interface ConnectorConfig extends ComponentConfig {
+    category?: ConnectorCategory;
+    categoryId: string;
+    implementations: Record<string, ConnectorImplementation>;
+    usageId: 'bidirectional' | 'destination' | 'source';
+    vendorAccountURL?: string;
+    vendorDocumentationURL?: string;
+    vendorHomeURL?: string;
+    version: string;
+}
+export interface ConnectorImplementation {
+    activeConnectionCount?: number;
+    canDescribe?: boolean;
+    id?: string;
+    authMethodId: 'apiKey' | 'disabled' | 'oAuth2' | 'none';
+    label?: Record<string, string>;
+    maxConnectionCount?: number;
+    params?: Record<string, string>[];
+}
+export interface ConnectorOperationSettings {
+    accountId?: string;
+    appCheckToken?: string;
+    sessionAccessToken?: string;
+}
+export interface AuditContentResult {
+    contentAuditConfig: DataViewContentAuditConfig;
+}
+export interface AuditContentSettings extends ConnectorOperationSettings {
+    chunkSize?: number;
+    encodingId: string;
+    path: string;
+    valueDelimiterId: ValueDelimiterId;
+}
+export interface CreateSettings extends ConnectorOperationSettings {
+    accountId?: string;
+    path: string;
+    structure: string;
+}
+interface DescribeSettings extends ConnectorOperationSettings {
+}
+interface DescribeResult {
+    description: ConnectionDescription;
+}
+export interface DropSettings extends ConnectorOperationSettings {
+    path: string;
+}
+export interface FindResult {
+    folderPath?: string;
+}
+export interface FindSettings extends ConnectorOperationSettings {
+    containerName?: string;
+    objectName: string;
+}
+export interface GetResult {
+    record?: string[] | Record<string, unknown>;
+}
+export interface GetSettings extends ConnectorOperationSettings {
+    id: string;
+    path: string;
+}
+export interface InitialiseSettings {
+    connectorStorageURLPrefix: string;
+}
+export interface ListResult {
+    cursor: string | number | undefined;
+    connectionNodeConfigs: ConnectionNodeConfig[];
+    isMore: boolean;
+    totalCount: number;
+}
+export interface ListSettings extends ConnectorOperationSettings {
+    folderPath: string;
+    limit?: number;
+    offset?: number;
+    totalCount?: number;
+}
+export interface PreviewResult {
+    data: Record<string, unknown>[] | Uint8Array;
+    typeId: 'jsonArray' | 'uint8Array';
+}
+export interface PreviewSettings extends ConnectorOperationSettings {
+    chunkSize?: number;
+    extension?: string;
+    path: string;
+}
+export interface RemoveSettings extends ConnectorOperationSettings {
+    keys: string[];
+    path: string;
+}
+export interface RetrieveSettings extends ConnectorOperationSettings {
+    chunkSize?: number;
+    encodingId: string;
+    path: string;
+    valueDelimiterId: ValueDelimiterId;
+}
+export interface RetrieveResult {
+    records: (string[] | Record<string, unknown>)[];
+}
+export interface RetrieveSummary {
+    byteCount: number;
+    commentLineCount: number;
+    emptyLineCount: number;
+    invalidFieldLengthCount: number;
+    lineCount: number;
+    recordCount: number;
+}
+export interface RetrieveTools {
+    csvParse: (options?: Options, callback?: Callback) => Parser | undefined;
+}
+export interface UpsertSettings extends ConnectorOperationSettings {
+    records: Record<string, unknown>[];
+    path: string;
+}
+type ConnectorCategory = {
+    id: string;
+    label: string;
+};
+export {};

package/dist/types/src/context.d.ts

@@ -0,0 +1,49 @@
+import { ComponentConfig } from './component';
+export interface ContextConfig extends ComponentConfig {
+    focuses: FocusConfig[];
+}
+export interface FocusConfig extends ComponentConfig {
+    models: ModelConfig[];
+}
+export interface ModelConfig extends ComponentConfig {
+    dimensions: DimensionConfig[];
+    entities: EntityConfig[];
+    views: ViewConfig[];
+}
+export interface DimensionConfig extends ComponentConfig {
+    id: string;
+    hierarchies: HierarchyConfig[];
+    label: Record<string, string>;
+}
+export interface HierarchyConfig extends ComponentConfig {
+    id: string;
+    label: Record<string, string>;
+}
+export interface EntityConfig extends ComponentConfig {
+    labelPlural: Record<string, string>;
+    characteristics: EntityCharacteristicConfig[];
+    computations: EntityComputationConfig[];
+    events: EntityEventConfig[];
+}
+export interface EntityCharacteristicConfig {
+    id: string;
+    label: Record<string, string>;
+}
+export interface EntityComputationConfig {
+    id: string;
+    label: Record<string, string>;
+}
+export interface EntityEventConfig {
+    id: string;
+    labelAction: Record<string, string>;
+    labelState: Record<string, string>;
+}
+export interface ViewConfig extends ComponentConfig {
+    placeholder: string;
+}
+export interface Event {
+    id?: number;
+    entityId: string;
+    effDate: number;
+    typeId: string;
+}

package/dist/types/src/dataView.d.ts

@@ -0,0 +1,71 @@
+import { ComponentConfig } from './component';
+import { Timestamp } from './timestamp';
+import { ConnectionColumnConfig, ConnectionNodeConfig } from './connection';
+export interface DataViewConfig extends ComponentConfig {
+    connectionId?: string;
+    connectionNodeConfig?: ConnectionNodeConfig;
+    previewConfig?: DataViewPreviewConfig;
+    contentAuditConfig?: DataViewContentAuditConfig;
+    relationshipsAuditConfig?: DataViewRelationshipsAuditConfig;
+}
+export interface DataViewContentAuditConfig {
+    asAt: Timestamp;
+    columns: ConnectionColumnConfig[];
+    commentLineCount: number;
+    emptyLineCount: number;
+    invalidFieldLengthCount: number;
+    duration: number;
+    lineCount: number;
+    recordCount: number;
+}
+export interface DataViewPreviewConfig {
+    asAt: Timestamp;
+    columnConfigs: ConnectionColumnConfig[];
+    dataFormatId: DataFormatId;
+    duration: number;
+    encodingConfidenceLevel?: number;
+    encodingId?: string;
+    errorMessage?: string;
+    hasHeaders?: boolean;
+    recordDelimiterId?: RecordDelimiterId;
+    records: {
+        isValid: boolean;
+        value: ParsedValue;
+    }[][];
+    size: number;
+    text: string;
+    valueDelimiterId?: ValueDelimiterId;
+}
+export interface DataViewRelationshipsAuditConfig {
+    placeholder?: string;
+}
+export interface EncodingConfig {
+    id: string;
+    groupLabel: string;
+    label: string;
+    isDetectable: boolean;
+    isDecodable: boolean;
+}
+type DataFormat = {
+    id: string;
+    label: string;
+};
+export declare const getDataFormat: (id: string, localeId?: string) => DataFormat;
+export declare const getDataFormats: (localeId?: string) => DataFormat[];
+type RecordDelimiter = {
+    id: string;
+    label: string;
+};
+export declare const getRecordDelimiter: (id: string, localeId?: string) => RecordDelimiter;
+export declare const getRecordDelimiters: (localeId?: string) => RecordDelimiter[];
+type ValueDelimiter = {
+    id: string;
+    label: string;
+};
+export declare const getValueDelimiter: (id: string, localeId?: string) => ValueDelimiter;
+export declare const getValueDelimiters: (localeId?: string) => ValueDelimiter[];
+export type ParsedValue = bigint | boolean | number | string | null;
+export type DataFormatId = 'dtv' | 'e/e' | 'jsonArray' | 'spss' | 'xls' | 'xlsx' | 'xml';
+export type RecordDelimiterId = '\n' | '\r' | '\r\n';
+export type ValueDelimiterId = '' | ':' | ',' | '!' | '0x1E' | ';' | ' ' | '\t' | '_' | '0x1F' | '|';
+export {};

package/dist/types/src/engine.d.ts

@@ -0,0 +1,15 @@
+import { ConnectionConfig } from './connection';
+import { AuditContentResult, ConnectorCallbackData, ConnectorOperationSettings, InitialiseSettings, ListResult, RetrieveResult } from './connector';
+import { DataViewPreviewConfig, EncodingConfig } from './dataView';
+type InitialiseEngine = (settings: InitialiseSettings) => Promise<void>;
+type ProcessConnectorRequest = (id: string, connectionConfig: ConnectionConfig, settings: ConnectorOperationSettings, callback?: ((callbackData: ConnectorCallbackData) => void) | undefined) => Promise<ConnectorInterfaceResult>;
+export type ConnectorInterfaceResult = AuditContentResult | DataViewPreviewConfig | ListResult | RetrieveResult;
+export interface Engine {
+    getEncodingConfigs: (localeId: string) => EncodingConfig[];
+    invokeWorker(errorEventCallback: (errorEvent: ErrorEvent) => void): EngineWorkerInterface;
+}
+export interface EngineWorkerInterface {
+    initialise: InitialiseEngine;
+    processConnectorRequest: ProcessConnectorRequest;
+}
+export {};

package/dist/types/src/errors.d.ts

@@ -0,0 +1,49 @@
+export interface SerialisedError {
+    body?: string;
+    componentName?: string;
+    info?: string;
+    locator: string;
+    message: string;
+    name: string;
+    stack?: string;
+}
+declare class DataPosError extends Error {
+    locator: string;
+    constructor(message: string, locator: string, options?: ErrorOptions);
+}
+export declare class ApplicationError extends DataPosError {
+    constructor(message: string, locator: string, options?: ErrorOptions);
+}
+export declare class APIError extends ApplicationError {
+    constructor(message: string, locator: string, options?: ErrorOptions);
+}
+export declare class EngineError extends ApplicationError {
+    constructor(message: string, locator: string, options?: ErrorOptions);
+}
+export declare class FetchError extends ApplicationError {
+    body: string;
+    constructor(message: string, locator: string, body: string, options?: ErrorOptions);
+}
+export declare class VueError extends ApplicationError {
+    componentName?: string;
+    info: string;
+    constructor(message: string, locator: string, info: string, componentName?: string, options?: ErrorOptions);
+}
+export declare class WindowRuntimeError extends ApplicationError {
+    constructor(message: string, locator: string, options?: ErrorOptions);
+}
+export declare class WindowPromiseRejectionError extends ApplicationError {
+    constructor(message: string, locator: string, options?: ErrorOptions);
+}
+export declare class OperationalError extends DataPosError {
+    constructor(message: string, locator: string, options?: ErrorOptions);
+}
+export declare function buildFetchError(response: {
+    status: number;
+    statusText: string;
+    text: () => Promise<string>;
+}, message: string, locator: string): Promise<FetchError>;
+export declare function concatenateSerialisedErrorMessages(serialisedErrors: SerialisedError[]): string;
+export declare function normalizeToError(value: unknown, fallbackMessage?: string): Error;
+export declare function serialiseError(error?: unknown): SerialisedError[];
+export {};

package/dist/types/src/eventQuery.d.ts

@@ -0,0 +1,4 @@
+import { ComponentConfig } from './component';
+export interface EventQueryConfig extends ComponentConfig {
+    placeholder?: string;
+}

package/dist/types/src/index.d.ts

@@ -0,0 +1,36 @@
+export { DefaultTimestamp } from './timestamp';
+export type { ComponentConfig, ComponentStatus } from './component';
+export type { ConnectionAuthorizationConfig, ConnectionColumnConfig, ConnectionConfig, ConnectionNodeConfig } from './connection';
+export type { DPAFileSystemFileHandle, Encoding, StorageTypeId, UsageTypeId } from './connection';
+export type { AuditContentResult, AuditContentSettings } from './connector';
+export type { Connector, ConnectorCallbackData, ConnectorConfig, ConnectorImplementation, ConnectorOperationSettings } from './connector';
+export type { CreateSettings } from './connector';
+export type { DropSettings } from './connector';
+export type { FindResult, FindSettings } from './connector';
+export type { GetResult, GetSettings } from './connector';
+export type { InitialiseSettings } from './connector';
+export type { ListResult, ListSettings } from './connector';
+export type { PreviewResult, PreviewSettings } from './connector';
+export type { RemoveSettings } from './connector';
+export type { RetrieveResult, RetrieveSettings, RetrieveSummary, RetrieveTools } from './connector';
+export type { UpsertSettings } from './connector';
+export type { ContextConfig, FocusConfig, ModelConfig, DimensionConfig, EntityCharacteristicConfig, EntityComputationConfig } from './context';
+export type { EntityConfig, EntityEventConfig, HierarchyConfig, ViewConfig, Event } from './context';
+export type { DataFormatId, EncodingConfig, RecordDelimiterId, ValueDelimiterId } from './dataView';
+export type { DataViewConfig, DataViewContentAuditConfig, DataViewPreviewConfig, DataViewRelationshipsAuditConfig, ParsedValue } from './dataView';
+export type { ConnectorInterfaceResult, Engine, EngineWorkerInterface } from './engine';
+export { APIError, ApplicationError, EngineError, FetchError, OperationalError, VueError, WindowRuntimeError, WindowPromiseRejectionError } from './errors';
+export type { SerialisedError } from './errors';
+export type { EventQueryConfig } from './eventQuery';
+export type { IPresenter, IPresenterConfig, IPresenterItemConfig } from './presenter';
+export type { ServiceData } from './service';
+export type { Timestamp } from './timestamp';
+export type { TutorialConfig } from './tutorial';
+export { buildFetchError, concatenateSerialisedErrorMessages, normalizeToError, serialiseError } from './errors';
+export { convertMillisecondsToTimestamp, getCurrentTimestamp } from './timestamp';
+export { convertODataTypeIdToUsageTypeId } from './utilities';
+export { extractExtensionFromPath, extractNameFromPath } from './utilities';
+export { formatNumberAsDecimalNumber, formatNumberAsDuration, formatNumberAsSize, formatNumberAsStorageSize, formatNumberAsWholeNumber } from './utilities';
+export { getDataFormats, getRecordDelimiters, getValueDelimiters } from './dataView';
+export { getComponentStatus } from './component';
+export { lookupMimeTypeForExtension } from './utilities';

package/dist/types/src/presenter.d.ts

@@ -0,0 +1,56 @@
+import { ComponentConfig } from './component';
+export interface IPresenter {
+    readonly config: IPresenterConfig;
+    list(path: string): IPresenterItemConfig[];
+    render(id: string, renderTo: string | HTMLElement): Promise<void>;
+}
+export interface IPresenterConfig extends ComponentConfig {
+    index: IPresenterItemConfig[];
+}
+export interface IPresenterItemConfig {
+    items?: IPresenterItemConfig[];
+    label: Record<string, string>;
+    name: string;
+    typeId: 'folder' | 'object';
+}
+export interface IPresentation {
+    readonly config: IPresentationConfig;
+    render(data: IPresentationData, renderTo: string | HTMLElement | null, localeId?: string): void;
+    resize: () => void;
+    update: () => void;
+}
+export interface IPresentationConfig {
+    id: string;
+    label: string;
+    typeId: 'declarative' | 'coded';
+    blocks?: IPresentationBlockConfig[];
+}
+export interface IPresentationBlockConfig {
+    config: IHighchartsBasicConfig | Record<string, unknown>;
+    typeId?: 'chartJSBasic' | 'cytoscapeMarkov' | 'cytoscapeNetwork' | 'highchartsBasic' | 'table' | 'text';
+}
+export interface IPresentationData {
+    dimensions: {
+        id: string;
+        type: {
+            id: string;
+            spanId?: string;
+            intervalId?: string;
+        };
+        intervals: {
+            label: string;
+        }[];
+    };
+    measures: {
+        id: string;
+        label: string;
+        values: number[];
+    }[];
+}
+interface IHighchartsBasicConfig {
+    series: {
+        typeId: TChartSeriesTypeId;
+    }[];
+}
+type TChartSeriesTypeId = 'areaLine' | 'areaSpline' | 'bar' | 'column' | 'line' | 'pyramid' | 'spline';
+export {};

package/dist/types/src/service.d.ts

@@ -0,0 +1,10 @@
+export interface ServiceData {
+    label: string;
+    monitorEvents: {
+        [vendorId: string]: {
+            [locationId: string]: {
+                [regionId: string]: [number, number];
+            };
+        };
+    };
+}

package/dist/types/src/timestamp.d.ts

@@ -0,0 +1,4 @@
+export type Timestamp = number;
+export declare const DefaultTimestamp: Timestamp;
+export declare const convertMillisecondsToTimestamp: (milliseconds: number) => Timestamp;
+export declare const getCurrentTimestamp: () => Timestamp;

package/dist/types/src/tutorial.d.ts

@@ -0,0 +1,4 @@
+import { ComponentConfig } from './component';
+export interface TutorialConfig extends ComponentConfig {
+    placeholder?: string;
+}

package/dist/types/src/utilities.d.ts

@@ -0,0 +1,9 @@
+export declare const convertODataTypeIdToUsageTypeId: (oDataTypeId: string) => string;
+export declare const extractNameFromPath: (itemPath: string) => string | undefined;
+export declare const extractExtensionFromPath: (itemPath: string) => string | undefined;
+export declare const formatNumberAsDecimalNumber: (number?: number, decimalPlaces?: number, minimumFractionDigits?: number, locale?: string) => string;
+export declare const formatNumberAsSize: (number?: number) => string;
+export declare const formatNumberAsStorageSize: (number?: number) => string;
+export declare const formatNumberAsDuration: (number?: number) => string;
+export declare const formatNumberAsWholeNumber: (number?: number, locale?: string) => string;
+export declare const lookupMimeTypeForExtension: (extension: string) => string;

package/dist/types/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vite').UserConfig;
+export default _default;

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@datapos/datapos-shared",
+    "license": "ISC",
+    "private": false,
+    "version": "0.1.867",
+    "type": "module",
+    "files": [
+        "dist"
+    ],
+    "module": "./dist/datapos-shared.es.js",
+    "exports": {
+        ".": {
+            "import": "./dist/datapos-shared.es.js",
+            "types": "./dist/types/src/index.d.ts"
+        }
+    },
+    "types": "./dist/types/src/index.d.ts",
+    "devDependencies": {
+        "@datapos/datapos-dev-operations": "^0.2.25",
+        "@typescript-eslint/eslint-plugin": "^8.32.0",
+        "@typescript-eslint/parser": "^8.32.0",
+        "csv-parse": "^5.6.0",
+        "eslint": "^9.26.0",
+        "eslint-plugin-import": "^2.31.0",
+        "prettier": "^3.5.3",
+        "typescript": "^5.8.3",
+        "vite": "^6.3.5",
+        "vite-plugin-dts": "^4.5.3"
+    },
+    "scripts": {
+        "audit": "npm audit",
+        "build": "npx vite build",
+        "bumpVersion": "node -e \"require('@datapos/datapos-dev-operations/scriptHelpers').bumpVersion()\"",
+        "check": "npx npm-check-updates && npm outdated",
+        "document": "npx npm-license-crawler --onlyDirectDependencies --production --relativeLicensePath --json LICENSES.json",
+        "format": "prettier --write *.ts",
+        "lint": "npx eslint **/*.ts",
+        "publishToNPM": "npm publish",
+        "release": "npm run syncWithGitHub && npm run build && npm run publishToNPM",
+        "syncWithGitHub": "npm run bumpVersion && node -e \"require('@datapos/datapos-dev-operations/scriptHelpers').syncWithGitHub()\"",
+        "test": "echo \"***** TEST SCRIPT NOT IMPLEMENTED. *****\"",
+        "updateDependencies": "npm run updateOperations",
+        "updateOperations": "npm install --save-dev @datapos/datapos-dev-operations@latest"
+    }
+}