@hamak/shared-utils 0.4.6 → 0.4.8

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@hamak/shared-utils",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "private": false,
   "type": "module",
   "description": "Shared utilities for path navigation, filesystem operations, and common helpers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "sideEffects": false,
+  "files": [
+    "dist"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/amah/app-framework.git",

package/src/core-utils-chrono.ts

@@ -1,21 +0,0 @@
-export class Chronometre {
-  private start : number
-  constructor() {
-    this.start = Date.now()
-  }
-
-  duration() : number {
-    return Date.now() - this.start
-  }
-
-  restart() : number {
-    const d = this.duration()
-    this.start = Date.now()
-
-    return d
-  }
-}
-
-export function chronometre() {
-  return new Chronometre()
-}

package/src/core-utils-comparator.ts

@@ -1,27 +0,0 @@
-export type Order = -1 | 0 | 1
-export type Weighted<T, W> = {value: T, weight: W}
-export type WeightFn<T> = (t : T) => number
-export type CompareFn<T> = (a : T, b : T, ...fns : [WeightFn<T>, ...WeightFn<T>[]]) => Order
-export function reverseOrder<T>(compareFn : CompareFn<T>) : CompareFn<T> {
-  return (a, b, fns) => - compareFn(a, b, fns) as Order
-}
-export function compare<T>(a : T, b : T, ...fns : WeightFn<T>[]) : Order {
-  if(fns.length === 0){
-    if(typeof a === "number" && typeof b === "number"){
-      fns = [(x : T) => x as unknown as number]
-    } else {
-      throw new Error(`Expecting at least one weight function when arguments are not numbers`)
-    }
-  }
-
-  for (const weightFn of fns) {
-    const aWeight = weightFn(a)
-    const bWeight = weightFn(b)
-    if(aWeight != bWeight){
-      return a < b ? -1 : 1
-    }
-  }
-  return 0
-}
-
-export const compareDesc = reverseOrder(compare)

package/src/core-utils-file.ts

@@ -1,10 +0,0 @@
-
-export interface FileInfo {
-  name: string;
-  path: string;
-  isDirectory: boolean;
-  size: number;
-  createdAt: Date;
-  updatedAt: Date;
-  content?: string; // Optional field for file content
-}

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

@@ -1,63 +0,0 @@
-import { DirectoryNode, fsutils } from './core-utils-filesystem';
-describe("Core utils filesystem", () => {
-  it("fsutils createDirectory - creates a file with intermediate directories", () => {
-    const root = fsutils.createRootDir([]);
-    const file = fsutils.createDescendent(root, "a/b/c.txt", "hello");
-
-    expect(file).toBeDefined();
-    expect(file?.type).toBe("file");
-    expect(file?.content).toBe("hello");
-
-    const dirA = root.children["a"];
-    expect(dirA?.type).toBe("directory");
-
-    const dirB = (dirA as DirectoryNode).children["b"];
-    expect(dirB?.type).toBe("directory");
-
-    const fileC = (dirB as DirectoryNode).children["c.txt"];
-    expect(fileC?.type).toBe("file");
-  });
-
-  it("fsutils createDirectory - throws if path conflicts with a file in intermediate segment", () => {
-    const conflict = fsutils.createFile("conflict", "not a dir");
-    const root = fsutils.createRootDir([conflict]);
-
-    expect(() =>
-      fsutils.createDescendent(root, "conflict/x.txt", "data")
-    ).toThrow(/is a file/);
-  });
-
-  it("fsutils createDirectory - throws if file exists and override is false", () => {
-    const existing = fsutils.createFile("existing.txt", "original");
-    const root = fsutils.createRootDir([
-      fsutils.createDir("dir", [existing])
-    ]);
-
-    expect(() =>
-      fsutils.createDescendent(root, "dir/existing.txt", "new content", "xs:any", undefined, false)
-    ).toThrow(/already exists/);
-  });
-
-  it("fsutils createDirectory - overrides file if override is true", () => {
-    const existing = fsutils.createFile("existing.txt", "original");
-    const root = fsutils.createRootDir([
-      fsutils.createDir("dir", [existing])
-    ]);
-
-    const newFile = fsutils.createDescendent(root, "dir/existing.txt", "new content", "xs:any", undefined, true);
-
-    expect(newFile?.content).toBe("new content");
-    expect((root.children["dir"] as DirectoryNode).children["existing.txt"]).toBe(newFile);
-  });
-
-  it("fsutils createDirectory - returns undefined if path is '.'", () => {
-    const root = fsutils.createRootDir([]);
-    const result = fsutils.createDescendent(root, ".", "data");
-    expect(result).toBeUndefined();
-  });
-
-  it("fsutils createDirectory - returns undefined if fromDir is undefined", () => {
-    const result = fsutils.createDescendent(undefined, "a/b.txt", "data");
-    expect(result).toBeUndefined();
-  });
-});

package/src/core-utils-filesystem.ts

@@ -1,232 +0,0 @@
-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

@@ -1,17 +0,0 @@
-/**
- * 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

@@ -1,36 +0,0 @@
-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

@@ -1,270 +0,0 @@
-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;
-  }
-
-}
-
-/**
- * Converts a path (string or string array) to an array of path segments.
- * If already an array, returns it as-is.
- * If a string, splits by '/' and filters out empty segments.
- *
- * @param path - The path to convert to segments
- * @returns Array of path segments
- *
- * @example
- * pathSteps('/foo/bar/baz') // ['foo', 'bar', 'baz']
- * pathSteps(['foo', 'bar']) // ['foo', 'bar']
- * pathSteps('foo//bar/') // ['foo', 'bar']
- */
-export function pathSteps(path: string | string[]): string[] {
-  if (Array.isArray(path)) {
-    return path;
-  }
-
-  return path.split('/').filter(s => s.trim().length > 0);
-}
-
-/**
- * Returns the parent path segments by removing the last segment.
- * Uses pathSteps internally to normalize the input path.
- *
- * @param path - The path to get parent segments from
- * @returns Array of parent path segments (all but last segment)
- *
- * @example
- * parentPathSteps('/foo/bar/baz') // ['foo', 'bar']
- * parentPathSteps(['foo', 'bar']) // ['foo']
- * parentPathSteps(['foo']) // []
- */
-export function parentPathSteps(path: string | string[]): string[] {
-  const steps = pathSteps(path);
-  return steps.length > 0 ? steps.slice(0, steps.length - 1) : steps;
-}