@rsconcept/domain 1.0.0

package/src/library/folder-tree.ts

@@ -0,0 +1,156 @@
+/**
+ * Module: Folder tree data structure. Does not support deletions.
+ */
+
+/**
+ * Represents single node of a {@link FolderTree}.
+ */
+export class FolderNode {
+  rank: number = 0;
+  text: string;
+  children: Map<string, FolderNode>;
+  parent: FolderNode | null;
+
+  filesInside: number = 0;
+  filesTotal: number = 0;
+
+  constructor(text: string, parent: FolderNode | null = null) {
+    this.text = text;
+    this.parent = parent;
+    this.children = new Map();
+    if (parent) {
+      this.rank = parent.rank + 1;
+    }
+  }
+
+  addChild(text: string): FolderNode {
+    const node = new FolderNode(text, this);
+    this.children.set(text, node);
+    return node;
+  }
+
+  hasPredecessor(target: FolderNode): boolean {
+    if (this.parent === target) {
+      return true;
+    } else if (!this.parent) {
+      return false;
+    }
+    let node = this.parent;
+    while (node.parent) {
+      if (node.parent === target) {
+        return true;
+      }
+      node = node.parent;
+    }
+    return false;
+  }
+
+  incrementFiles(count: number = 1): void {
+    this.filesInside = this.filesInside + count;
+    this.incrementTotal(count);
+  }
+
+  incrementTotal(count: number = 1): void {
+    this.filesTotal = this.filesTotal + count;
+    if (this.parent) {
+      this.parent.incrementTotal(count);
+    }
+  }
+
+  getPath(): string {
+    const suffix = this.text ? `/${this.text}` : '';
+    if (!this.parent) {
+      return suffix;
+    } else {
+      return this.parent.getPath() + suffix;
+    }
+  }
+}
+
+/** Represents a FolderTree. */
+export class FolderTree {
+  roots = new Map<string, FolderNode>();
+
+  constructor(arr?: string[]) {
+    arr?.forEach(path => this.addPath(path));
+  }
+
+  at(path: string): FolderNode | undefined {
+    let parse = ChopPathHead(path);
+    if (!this.roots.has(parse.head)) {
+      return undefined;
+    }
+    let node = this.roots.get(parse.head)!;
+    while (parse.tail !== '') {
+      parse = ChopPathHead(parse.tail);
+      if (!node.children.has(parse.head)) {
+        return undefined;
+      }
+      node = node.children.get(parse.head)!;
+    }
+    return node;
+  }
+
+  getTree(): FolderNode[] {
+    const result: FolderNode[] = [];
+    this.roots.forEach(root => this.visitNode(root, result));
+    return result;
+  }
+
+  private visitNode(target: FolderNode, result: FolderNode[]) {
+    result.push(target);
+    [...target.children.keys()]
+      .sort((a, b) => a.localeCompare(b))
+      .forEach(key => this.visitNode(target.children.get(key)!, result));
+  }
+
+  addPath(path: string, filesCount: number = 1): FolderNode {
+    let parse = ChopPathHead(path);
+    if (!parse.head) {
+      throw Error(`Invalid path ${path}`);
+    }
+    let node = this.roots.has(parse.head) ? this.roots.get(parse.head)! : this.addNode(parse.head);
+    while (parse.tail !== '') {
+      parse = ChopPathHead(parse.tail);
+      if (node.children.has(parse.head)) {
+        node = node.children.get(parse.head)!;
+      } else {
+        node = this.addNode(parse.head, node);
+      }
+    }
+    node.incrementFiles(filesCount);
+    return node;
+  }
+
+  private addNode(text: string, parent?: FolderNode): FolderNode {
+    if (!parent) {
+      const newNode = new FolderNode(text);
+      this.roots.set(text, newNode);
+      return newNode;
+    } else {
+      return parent.addChild(text);
+    }
+  }
+}
+
+// ========= Internals =======
+function ChopPathHead(path: string) {
+  if (path?.at(0) !== '/') {
+    return {
+      head: '',
+      tail: ''
+    };
+  }
+  const slash = path.indexOf('/', 1);
+  if (slash === -1) {
+    return {
+      head: path.substring(1),
+      tail: ''
+    };
+  } else {
+    return {
+      head: path.substring(1, slash),
+      tail: path.substring(slash)
+    };
+  }
+}

package/src/library/index.ts

@@ -0,0 +1,46 @@
+export { FolderNode, FolderTree } from './folder-tree';
+export {
+  AccessPolicy,
+  type CurrentVersion,
+  type LibraryItem,
+  type LibraryItemReference,
+  LibraryItemType,
+  LocationHead,
+  type VersionInfo
+} from './library';
+export type { Block } from './oss';
+export {
+  type CstSubstituteInfo,
+  NodeType,
+  type Operation,
+  type OperationInput,
+  type OperationSchema,
+  type OperationSchemaStats,
+  type OperationSynthesis,
+  OperationType,
+  type OssItem,
+  type SubstitutionErrorDescription,
+  SubstitutionErrorType
+} from './oss';
+export { type OssLayout, type Position2D } from './oss-layout';
+export { RSEngine } from './rsengine';
+export {
+  type ArgumentValue,
+  type Attribution,
+  type Constituenta,
+  CstClass,
+  CstStatus,
+  CstType,
+  type RSForm,
+  type RSFormStats,
+  type Substitution,
+  type TypeInfo
+} from './rsform';
+export {
+  type BasicBinding,
+  type BasicsContext,
+  DEFAULT_VALUE_TEXT,
+  EvalStatus,
+  type RSModel,
+  type RSModelStats
+} from './rsmodel';

package/src/library/library-api.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+
+import { validateLocationFormat } from './library-api';
+
+const validateLocationData = [
+  ['', 'false'],
+  ['U/U', 'false'],
+  ['/A', 'false'],
+  ['/U/user@mail', 'false'],
+  ['U/u\\asdf', 'false'],
+  ['/U/ asdf', 'false'],
+  ['/User', 'false'],
+  ['//', 'false'],
+  ['/S/1 ', 'false'],
+  ['/S/1/2 /3', 'false'],
+
+  ['/P', 'true'],
+  ['/L', 'true'],
+  ['/U', 'true'],
+  ['/S', 'true'],
+  ['/S/Вася пупки', 'true'],
+  ['/S/123', 'true'],
+  ['/S/1234', 'true'],
+  ['/S/1/!asdf/тест тест', 'true']
+];
+
+describe('Testing location validation', () => {
+  it.each(validateLocationData)('isValid %p', (input: string, expected: string) => {
+    const result = validateLocationFormat(input);
+    expect(String(result)).toBe(expected);
+  });
+});

package/src/library/library-api.ts

@@ -0,0 +1,11 @@
+const LOCATION_REGEXP = /^\/[PLUS]((\/[!\d\p{L}]([!\d\p{L}\- ]*[!\d\p{L}])?)*)?$/u; // cspell:disable-line
+
+/** Combining head and body into location. */
+export function combineLocation(head: string, body?: string): string {
+  return body ? `${head}/${body}` : head;
+}
+
+/** Validation location against regexp. */
+export function validateLocationFormat(location: string): boolean {
+  return LOCATION_REGEXP.test(location);
+}

package/src/library/library.ts

@@ -0,0 +1,61 @@
+/**
+ * Module: Models for LibraryItem.
+ */
+
+/** Represents type of library items. */
+export const LibraryItemType = {
+  RSFORM: 'rsform',
+  OSS: 'oss',
+  RSMODEL: 'rsmodel'
+} as const;
+export type LibraryItemType = (typeof LibraryItemType)[keyof typeof LibraryItemType];
+
+/** Represents Access policy for library items.*/
+export const AccessPolicy = {
+  PUBLIC: 'public',
+  PROTECTED: 'protected',
+  PRIVATE: 'private'
+} as const;
+export type AccessPolicy = (typeof AccessPolicy)[keyof typeof AccessPolicy];
+
+/** Represents valid location headers. */
+export const LocationHead = {
+  USER: '/U',
+  COMMON: '/S',
+  LIBRARY: '/L',
+  PROJECTS: '/P'
+} as const;
+export type LocationHead = (typeof LocationHead)[keyof typeof LocationHead];
+
+/** Represents {@link LibraryItem} minimal reference data. */
+export interface LibraryItemReference {
+  id: number;
+  alias: string;
+}
+
+/** Represents library item common data typical for all item types. */
+export interface LibraryItem {
+  id: number;
+  item_type: LibraryItemType;
+  alias: string;
+  title: string;
+  description: string;
+  visible: boolean;
+  read_only: boolean;
+  location: string;
+  access_policy: AccessPolicy;
+  time_create: string;
+  time_update: string;
+  owner: number | null;
+}
+
+/** Represents library item version information. */
+export interface VersionInfo {
+  id: number;
+  version: string;
+  description: string;
+  time_create: string;
+}
+
+/** Represents current version */
+export type CurrentVersion = number | 'latest';