@hamak/shared-utils 0.4.1

package/src/core-utils-filesystem.ts

@@ -0,0 +1,232 @@
+import { Path, Pathway } from './core-utils-pathway';
+import { Holder } from './core-utils-types';
+import { PathwayResolver } from './core-utils-pathway-resolver';
+
+//export type FileContentSchema = string | {schemaObject : SchemaNode, namespace? : string}
+export type FileContentSchema = string | { schemaObject: string /*TypeString*/, namespace?: string }
+
+export interface FileSystemState {
+  root: DirectoryNode
+}
+
+export interface FileMemoState {
+  originalContent: Holder
+  modified: boolean // tell whether the current file content is modified compared to original
+}
+
+export interface FileSystemNodeState {
+  contentLoaded: boolean
+  contentLoading: boolean
+  contentLoadError?: { code?: string, message?: string }
+  memo?: FileMemoState
+  contentHistory: any[]
+
+  extensionStates: Record<string, unknown>
+}
+
+
+export function fileSystemNodeInitialState(contentPresent = true): FileSystemNodeState {
+  return {
+    contentLoaded: contentPresent,
+    contentLoading: false,
+    contentLoadError: undefined,
+    contentHistory: [],
+    extensionStates: {}
+  }
+}
+
+
+export interface FileSystemNodeBase {
+  type: 'directory' | 'file'
+  name: string
+  state: FileSystemNodeState
+}
+
+
+export interface DirectoryNode extends FileSystemNodeBase {
+  type: 'directory'
+  children: Record<string, FileSystemNode>
+}
+
+export interface FileNode<T = any> extends FileSystemNodeBase {
+  type: 'file'
+  content: T
+  schema: string | FileContentSchema
+}
+
+export type FileSystemNode = DirectoryNode | FileNode
+
+function isRoot(node : FileSystemNode) : boolean {
+  switch (node.type) {
+    case "directory":{
+      return node.name === null || node.name === undefined || node.name.trim() === "" || node.name.trim() === "/"
+    }
+    case "file":{
+      return false
+    }
+  }
+}
+
+export class DirectoryNodePathwayResolver implements PathwayResolver<FileSystemNode> {
+  constructor(readonly root: FileSystemNode) {
+  }
+
+  resolve(path: string | Pathway | string[]): FileSystemNode | undefined {
+    return fsutils.resolveFileNode(this.root, path)
+  }
+
+  changeDIr(path : Path) : DirectoryNodePathwayResolver {
+    const fileNode = this.resolve(path)
+    if(fileNode === undefined){
+      throw new Error(`No such directory: ${Pathway.asString(path)}`)
+    } else {
+      switch (fileNode.type) {
+        case "directory": return new DirectoryNodePathwayResolver(fileNode)
+        case "file": throw new Error(`Path is not directory: ${Pathway.asString(path)}`)
+      }
+    }
+
+  }
+}
+class FilesystemUtil{
+  createRootDir(children : FileSystemNode[], state = fileSystemNodeInitialState()) : DirectoryNode {
+   return this.createDir("", children, state)
+  }
+  createDir(name : string, children : FileSystemNode[], state = fileSystemNodeInitialState()) : DirectoryNode {
+    return {
+      type: "directory", name, state,
+      children: children.reduce((acc, child) => ({...acc, [child.name]: child}), {} as Record<string, FileSystemNode>)
+    }
+  }
+  createDirs(path : Path, children : FileSystemNode[], state = fileSystemNodeInitialState()) : DirectoryNode {
+    const pathway = Pathway.of(path)
+    const dir = pathway.getSegments().reverse().reduce((acc, segment) => {
+      return this.createDir(segment, acc === undefined ? children : [acc])
+    }, undefined as DirectoryNode | undefined)
+
+    if(dir === undefined){
+      throw new Error(`Unable de create dir '${path}'`)
+    }
+
+    return pathway.isAbsolute() ? this.createRootDir([dir]) : dir
+  }
+
+  createFile(name : string, content : any, schema = "xs:any", state = fileSystemNodeInitialState()) : FileNode {
+    return {type: "file", name, content, schema, state}
+  }
+
+  resolveFileNode(fromDir: FileSystemNode | undefined, path : Path) : FileSystemNode | undefined {
+    if(fromDir === undefined){
+      return undefined
+    }
+    const pathway = Pathway.of(path)
+    if (pathway.isAbsolute() && !isRoot(fromDir)) {
+      return undefined
+    }
+
+    const result = pathway.getSegments().reduce((acc, segment) => {
+      if (acc === undefined) {
+        return undefined
+      } else {
+        switch (acc.type) {
+          case "directory": {
+            return acc.children?.[segment]
+          }
+            break;
+          case "file": {
+            return undefined
+          }
+            break;
+          default: {
+            return undefined
+          }
+        }
+      }
+    }, fromDir as FileSystemNode | undefined)
+
+    return result
+
+  }
+
+  asFile<T = any>(fsn : FileSystemNode | undefined) : FileNode<T> | undefined {
+    return fsn?.type === "file" ? fsn : undefined
+  }
+
+  asDirectory(fsn : FileSystemNode | undefined) : DirectoryNode | undefined {
+    return fsn?.type === "directory" ? fsn : undefined
+  }
+  resolveDescendent(fromDir: FileSystemNode | undefined, path : Path) : FileSystemNode | undefined {
+    const pathway = Pathway.of(path)
+    return pathway.isCurrentDir() ? undefined : this.resolveFileNode(fromDir, pathway)
+  }
+
+  /**
+   * Set a file node content a specified location. It create intermediary directories and target if missed location.
+   * @param fromDir
+   * @param path
+   * @param content
+   * @param schema
+   * @param state
+   */
+  createDescendent(
+    fromDir: FileSystemNode | undefined,
+    path: Path,
+    content: any,
+    schema = "xs:any",
+    state = fileSystemNodeInitialState(),
+    override = false
+  ): FileNode | undefined {
+    if (!fromDir) return undefined;
+
+    const pathway = Pathway.of(path);
+    if (pathway.isCurrentDir()) return undefined;
+
+    const segments = pathway.getSegments();
+    if (segments.length === 0) return undefined;
+
+    if (fromDir.type !== "directory") {
+      throw new Error("Cannot create descendent on a non-directory node.");
+    }
+
+    let currentDir = fromDir;
+
+    for (let i = 0; i < segments.length - 1; i++) {
+      const segment = segments[i];
+      let nextNode = currentDir.children[segment];
+
+      if (!nextNode) {
+        // Create intermediate directory
+        const newDir: DirectoryNode = this.createDir(segment, []);
+        currentDir.children[segment] = newDir;
+        nextNode = newDir;
+      }
+
+      if (nextNode.type !== "directory") {
+        throw new Error(`Path conflict: '${segment}' is a file, expected a directory.`);
+      }
+
+      currentDir = nextNode;
+    }
+
+    const fileName = segments[segments.length - 1];
+    const existingNode = currentDir.children[fileName];
+
+    if (existingNode) {
+      if (existingNode.type !== "file") {
+        throw new Error(`Path conflict: '${fileName}' exists and is not a file.`);
+      }
+      if (!override) {
+        throw new Error(`File '${fileName}' already exists and override is disabled.`);
+      }
+    }
+
+    const fileNode: FileNode = this.createFile(fileName, content, schema, state);
+
+    currentDir.children[fileName] = fileNode;
+
+    return fileNode;
+  }
+
+}
+
+export const fsutils = new FilesystemUtil()

package/src/core-utils-fqn.ts

@@ -0,0 +1,17 @@
+/**
+ * Unresolved qualified name by either namespace of prefix
+ */
+export class LexicalQualifiedName {
+  constructor(public readonly namespace: string | undefined, public readonly prefix : string | undefined, public readonly name : string) {
+  }
+
+  isEqualTo(other : LexicalQualifiedName) : boolean {
+    if((this.name === undefined && other.name === undefined)
+        || (this.name === null && other.name === null)){
+      return false
+    } else {
+      return this.namespace === other.namespace && this.prefix === other.prefix && this.name === other.name
+    }
+  }
+
+}

package/src/core-utils-pathway-resolver.ts

@@ -0,0 +1,36 @@
+import {Path, Pathway} from "./core-utils-pathway";
+
+export interface PathwayResolver<T>{
+  resolve(path : string | string[] | Pathway) : T | undefined
+}
+
+export class RecordPathwayResolver<T> implements PathwayResolver<T> {
+  constructor(readonly record : Record<string, T>) {
+  }
+
+  resolve(path: string | string[] | Pathway): T | undefined {
+    const key = Pathway.asString(path)
+    return this.record[key]
+  }
+}
+
+export class EmptyPathwayResolver<T> implements PathwayResolver<T> {
+  resolve(path: string | string[] | Pathway): T | undefined {
+    return undefined
+  }
+}
+
+export class RelativePathwayResolver<T> implements PathwayResolver<T> {
+  private relativePathway : Pathway
+  constructor(readonly parentResolver : PathwayResolver<T>, readonly path : Path) {
+    this.relativePathway = Pathway.of(path)
+  }
+  resolve(path: string | string[] | Pathway): T | undefined {
+    const pathway = Pathway.of(path)
+    if(pathway.isAbsolute()){
+      return this.parentResolver.resolve(path)
+    } else {
+      return this.parentResolver.resolve(this.relativePathway.resolve(pathway))
+    }
+  }
+}

package/src/core-utils-pathway.ts

@@ -0,0 +1,232 @@
+export type Path = string | string[] | Pathway
+/**
+ * Class representing a normalized pathway.
+ */
+export class Pathway {
+  private segments: string[];
+  private isAbsolutePath: boolean;
+
+  /**
+   * Creates a Pathway instance.
+   * @param path - The pathway to normalize, either as a string or an array of strings.
+   *                An empty array or "." represents the current directory.
+   */
+  constructor(path: string | string[] | null | undefined) {
+    if (path == null || path === "." || (Array.isArray(path) && path.length === 0)) {
+      this.segments = [];
+      this.isAbsolutePath = false;
+    } else {
+      this.isAbsolutePath = Array.isArray(path) ? path[0].startsWith('/') : path.startsWith('/');
+      this.segments = this.normalizePath(path);
+    }
+  }
+
+  /**
+   * Factory method to create a Pathway instance.
+   * @param path - The pathway to normalize, either as a string or an array of strings.
+   * @returns A new Pathway instance.
+   */
+  public static of(path: string | string[] | null | undefined | Pathway): Pathway {
+    if(path !== undefined && path !== null && typeof path === "object" && !Array.isArray(path)) {
+      return path
+    } else {
+      return new Pathway(path);
+    }
+  }
+
+  /**
+   * Normalizes a pathway by converting it into an array of segments.
+   * @param path - The pathway to normalize, either as a string or an array of strings.
+   * @returns An array of normalized path segments, or an empty array if the input is null or undefined.
+   */
+  private normalizePath(path: string | string[] | null | undefined): string[] {
+    if (path == null) {
+      return [];
+    }
+
+    const segments = Array.isArray(path) ? path : path.split('/');
+    return segments
+      .reduce((acc, segment) => {
+        if (segment === "." || segment === "") {
+          return acc;
+        }
+        return acc.concat(segment.split('/'));
+      }, [] as string[])
+      .filter(segment => segment.length > 0);
+  }
+
+  /**
+   * Returns the normalized path segments.
+   * @returns An array of normalized path segments.
+   */
+  public getSegments(): string[] {
+    return this.segments;
+  }
+
+  public isCurrentDir(){
+    return this.getSegments().length === 0
+  }
+
+  /**
+   * Converts the normalized path segments back to a string.
+   * @returns The normalized path as a string.
+   */
+  public toString(): string {
+    return this.isAbsolute() ? '/' + this.segments.join('/') : this.segments.join('/');
+  }
+
+  /**
+   * Checks if the pathway is absolute.
+   * @returns True if the pathway is absolute, false otherwise.
+   */
+  public isAbsolute(): boolean {
+    return this.isAbsolutePath;
+  }
+
+  /**
+   * Checks if the pathway is relative.
+   * @returns True if the pathway is relative, false otherwise.
+   */
+  public isRelative(): boolean {
+    return !this.isAbsolutePath;
+  }
+
+  /**
+   * Resolves the current pathway with another pathway or string.
+   * @param otherPath - The other pathway or string to resolve against.
+   * @returns A new Pathway instance representing the resolved path.
+   */
+  public resolve(otherPath: Pathway | string | string[]): Pathway {
+    const otherSegments = otherPath instanceof Pathway ? otherPath.getSegments() : this.normalizePath(otherPath);
+    const resolvedSegments = [...this.segments];
+
+    if (otherPath instanceof Pathway ? otherPath.isAbsolute() : (Array.isArray(otherPath) ? otherPath[0].startsWith('/') : otherPath.startsWith('/'))) {
+      return new Pathway(otherSegments);
+    }
+
+    for (const segment of otherSegments) {
+      if (segment === '..') {
+        if (resolvedSegments.length > 0 && resolvedSegments[resolvedSegments.length - 1] !== '..') {
+          resolvedSegments.pop();
+        } else {
+          resolvedSegments.push(segment);
+        }
+      } else if (segment !== '.') {
+        resolvedSegments.push(segment);
+      }
+    }
+
+    return new Pathway(this.isAbsolute() ? ["/", ...resolvedSegments] : resolvedSegments);
+  }
+
+  /**
+   * Gets the parent directory of the current pathway.
+   * @returns A new Pathway instance representing the parent directory.
+   */
+  public getParent(): Pathway {
+    if (this.segments.length === 0) {
+      return new Pathway(null);
+    }
+    const parentSegments = this.segments.slice(0, -1);
+    return new Pathway(this.isAbsolute() ? ["/", ...parentSegments] : parentSegments);
+  }
+
+  /**
+   * Gets the current directory of the pathway.
+   * @returns The current directory as a string.
+   */
+  public getCurrentDirectory(): string {
+    if (this.segments.length === 0) {
+      return '';
+    }
+    return this.segments[this.segments.length - 1];
+  }
+
+  /**
+   * Static method to get the absolute path of the root.
+   * @returns A new Pathway instance representing the root path.
+   */
+  public static ofRoot(): Pathway {
+    return new Pathway('/');
+  }
+
+  /**
+   * Determines the relative path from this pathway to another pathway.
+   * @param otherPath - The other pathway to relativize against.
+   * @returns A new Pathway instance representing the relative path.
+   */
+  public relativize(otherPath: Pathway | string | string[]): Pathway {
+    const otherSegments = otherPath instanceof Pathway ? otherPath.getSegments() : this.normalizePath(otherPath);
+
+    if (this.isAbsolute() !== (otherPath instanceof Pathway ? otherPath.isAbsolute() : (Array.isArray(otherPath) ? otherPath[0].startsWith('/') : otherPath.startsWith('/')))) {
+      throw new Error("Cannot relativize between absolute and relative paths");
+    }
+
+    let commonLength = 0;
+    const maxLength = Math.min(this.segments.length, otherSegments.length);
+    for (let i = 0; i < maxLength; i++) {
+      if (this.segments[i] !== otherSegments[i]) {
+        break;
+      }
+      commonLength++;
+    }
+
+    const upSegments = this.segments.slice(commonLength).map(() => '..');
+    const downSegments = otherSegments.slice(commonLength);
+
+    return new Pathway(upSegments.concat(downSegments));
+  }
+
+  /**
+   * Checks if the given path is a descendant of the current pathway.
+   * @param otherPath - The other pathway to check.
+   * @returns True if the given path is a descendant, false otherwise.
+   */
+  public isDescendant(otherPath: Pathway | string | string[]): boolean {
+    const otherSegments = otherPath instanceof Pathway ? otherPath.getSegments() : this.normalizePath(otherPath);
+
+    if (otherSegments.length < this.segments.length) {
+      return false;
+    }
+
+    for (let i = 0; i < this.segments.length; i++) {
+      if (this.segments[i] !== otherSegments[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+
+  static isRelativePath(path : Path) : boolean {
+    const pathway = typeof path === "object" && !Array.isArray(path) ? path : Pathway.of(path)
+    return pathway.isRelative()
+  }
+
+  static asString(path : Path) : string {
+    if(typeof path === "string"){
+      return path
+    } else {
+      const pathway = typeof path === "object" && !Array.isArray(path)? path : Pathway.of(path)
+      return pathway.toString()
+    }
+  }
+
+  static getName(path: string | string[] | Pathway) {
+    let name: string
+    switch (typeof path) {
+      case "string": {
+        name = path
+      }
+        break
+      case "object": {
+        const segments = Array.isArray(path) ? path : path.getSegments()
+        name = segments[segments.length - 1]
+      }
+        break
+    }
+    return name;
+  }
+
+}

package/src/core-utils-registry.ts

@@ -0,0 +1,23 @@
+import { Resolver } from './core-utils-resolver';
+export class SimpleRegistry<T> implements Resolver<T>{
+  private readonly records : Map<string | undefined, Record<string, T>> = new Map()
+  resolve(namespace: string | undefined, prefix: string | undefined, variableName: string): T | undefined {
+    if (prefix !== undefined){
+      throw new Error(`Not support namespace prefix for name resolution : '${prefix}'`)
+    } else {
+      const record = this.records.get(namespace)
+      return record?.[variableName]
+    }
+  }
+
+  register(namespace: string | undefined, variableName: string, t : T) {
+    let namespaceRecord = this.records.get(namespace)
+    if(namespaceRecord === undefined){
+      namespaceRecord = {}
+      this.records.set(namespace, namespaceRecord)
+    }
+
+    namespaceRecord[variableName] = t
+  }
+}
+

package/src/core-utils-resolver.ts

@@ -0,0 +1,75 @@
+export interface Resolver<T> {
+  resolve(namespace: string | undefined, prefix: string | undefined, variableName: string): T | undefined
+}
+
+export class RecordResolver<T> implements Resolver<T> {
+  constructor(readonly variables: Record<string, T>, readonly parent?: Resolver<T>) {
+  }
+
+  resolve(namespace: string | undefined, prefix: string | undefined, variableName: string): T | undefined {
+    return this.variables[variableName] ?? this.parent?.resolve(undefined, undefined, variableName)
+  }
+}
+
+export class QualifiedNameResolverImpl<T> implements Resolver<T> {
+  readonly entries = new Map<string| undefined, Map<string, T>>()
+  constructor(readonly ignoreNs = false) {
+  }
+  resolve(namespace: string | undefined, prefix: string | undefined, name: string): T | undefined {
+    if(!this.ignoreNs && namespace !== undefined && namespace !== null){
+      throw new Error(`Not support namespace URI but passed as parameter: ${namespace}`)
+    }
+    return this.entries.get(namespace)?.get(name)
+  }
+
+  setEntries(prefix: string | undefined, entries : Record<string, T>){
+    const prefixEntry = this.getOrCreatePrefixEntry(prefix)
+    Object.entries(entries).forEach(([k, v]) => prefixEntry.set(k, v))
+  }
+  setEntry(prefix: string | undefined, name : string, entry : T){
+    const prefixEntry = this.getOrCreatePrefixEntry(prefix)
+    prefixEntry.set(name, entry)
+  }
+
+  private getOrCreatePrefixEntry(prefix : string | undefined) : Map<string, T> {
+    let prefixEntry = this.entries.get(prefix)
+    if(prefixEntry === undefined){
+      prefixEntry = new Map<string, T>()
+      this.entries.set(prefix, prefixEntry)
+    }
+
+    return prefixEntry
+  }
+
+}
+
+export type ResolverPredicate = (namespace: string | undefined, prefix: string | undefined, name: string) => boolean
+
+export class SimpleResolver<T> implements Resolver<T> {
+  constructor(readonly parent: Resolver<T> | undefined, readonly namespace: string | undefined, readonly variableName: string | undefined, readonly variableValue: T) {
+  }
+
+  resolve(namespace: string | undefined, prefix: string | undefined, variableName: string): T | undefined {
+    if (this.namespace === namespace && this.variableName === variableName) {
+      return this.variableValue
+    }
+
+    return this.parent?.resolve(namespace, prefix, variableName)
+  }
+}
+
+export class ChainedResolver<T> implements Resolver<T> {
+  constructor(readonly resolvers: Resolver<T>[]) {
+  }
+
+  resolve(namespace: string | undefined, prefix: string | undefined, variableName: string): T | undefined {
+    for (const resolver of this.resolvers) {
+      const s = resolver.resolve(namespace, prefix, variableName)
+      if (s !== undefined) {
+        return s
+      }
+    }
+
+    return undefined
+  }
+}

package/src/core-utils-stack.spec.ts

@@ -0,0 +1,42 @@
+import stack from "./core-utils-stack";
+
+describe("Core util stack", () => {
+  it("fromArray should work", () => {
+    const itinerary = stack.fromArray([1, 2, 3, 4])
+
+    expect(itinerary?.value).toBe(4)
+    expect(itinerary?.parent?.parent?.parent?.value).toBe(1)
+
+    expect(stack.fromArray([])).toBe(undefined)
+    expect(stack.fromArray(undefined)).toBe(undefined)
+  })
+  it("reduce should work", () => {
+    const itinerary = stack.fromArray([1, 2, 3, 4])
+
+    const result = stack.reduce(itinerary, (acc, t) => acc + t, 0);
+    expect(result).toBe(10)
+  })
+  it("reduce order should work", () => {
+    const itinerary = stack.fromArray([1, 2, 3, 4])
+
+    const result = stack.reduce(itinerary, (acc, t) => [...acc, t], [] as number[]);
+    expect(result).toStrictEqual([1, 2, 3, 4])
+  })
+  it("equal should work", () => {
+    expect(stack.equal(undefined, undefined)).toBe(false)
+    expect(stack.equal(null, null)).toBe(false)
+    expect(stack.equal(undefined, null)).toBe(false)
+    expect(stack.equal(null, undefined)).toBe(false)
+
+    expect(stack.equal(stack.fromArray([1, 2, 3, 4]), undefined)).toBe(false)
+    expect(stack.equal(stack.fromArray([1, 2, 3, 4]), null)).toBe(false)
+
+    expect(stack.equal(undefined, stack.fromArray([1, 2, 3, 4]))).toBe(false)
+    expect(stack.equal(null, stack.fromArray([1, 2, 3, 4]))).toBe(false)
+
+    expect(stack.equal(stack.fromArray([1]), stack.fromArray([2]))).toBe(false)
+    expect(stack.equal(stack.fromArray([1]), stack.fromArray([1, 2]))).toBe(false)
+
+    expect(stack.equal(stack.fromArray([1, 2, 3, 4]), stack.fromArray([1, 2, 3, 4]))).toBe(true)
+  })
+})