@hamak/shared-utils 0.4.1

package/dist/itinerary/itinerary.d.ts

@@ -0,0 +1,86 @@
+import { StackElement } from "./stack";
+import { HyperLayerNode } from "./hyper-layer-node";
+export type ObjectId = string | number;
+interface PropertyValuePair<P = string, V = any> {
+    propertyName: P;
+    propertyValue: V;
+}
+export interface ItineraryStepBase {
+    type: "property" | "lookup" | "position";
+}
+export interface PropertyStep extends ItineraryStepBase {
+    type: "property";
+    propertyName: string;
+}
+export interface LookupStep extends ItineraryStepBase {
+    type: "lookup";
+    keys: PropertyValuePair[];
+}
+export interface PositionStep extends ItineraryStepBase {
+    type: "position";
+    position: number;
+}
+export type ItineraryStep = PropertyStep | LookupStep | PositionStep;
+export type Itinerary = StackElement<ItineraryStep>;
+export interface ConstructiveItinerary {
+    itinerary: Itinerary | undefined;
+    prototypes: StackElement<any> | undefined;
+}
+export type StepValueNodeType = Array<any> | Record<string | number, any>;
+export declare function constructiveItinerary(steps: Array<string | number | StepValueNodeType>): ConstructiveItinerary;
+export declare function areSameItineraryStep(step1: ItineraryStep | null | undefined, step2: ItineraryStep | null | undefined): boolean;
+export declare function itineraryOf(...args: (string | number)[]): Itinerary | undefined;
+export declare function itineraryOverlay(it: Itinerary | undefined): Itinerary;
+export declare function itineraryToStepArray(itinerary: Itinerary | undefined): ItineraryStep[];
+export declare function propertyStep(propertyName: string): PropertyStep;
+export declare function positionStep(position: number): PositionStep;
+export declare function lookupStep(criteria: Record<string, any>): LookupStep;
+export declare function xpathFromStack(path?: StackElement<ItineraryStep>): string;
+export declare function navigate(from: any, itinerary: Itinerary | undefined, prototype?: StackElement<any>): any;
+export declare function navigateStep(from: any, step: ItineraryStep, prototype?: any): any;
+export declare function navigationDepth(from: any, itinerary: Itinerary | undefined, originalPath?: string): {
+    value: any;
+    path: string;
+    originalPath: string;
+};
+declare class OverlayNavigator {
+    navigate<T>(from: HyperLayerNode<T>, itinerary: Itinerary | undefined): HyperLayerNode<T> | undefined;
+    protected navigateStep<T>(from: HyperLayerNode<T>, step: ItineraryStep): HyperLayerNode<T> | undefined;
+}
+export declare const overlayNavigator: OverlayNavigator;
+/**
+ * Same as {navigate} but try to path missing data node using prototype parameter
+ * @param from
+ * @param itinerary
+ * @param prototype
+ */
+export declare function ensurePath(from: any, itinerary: Itinerary | undefined, prototype?: any): any;
+interface PointerBase {
+    type: "absolute" | "relative";
+    itinerary: ItineraryStep[];
+}
+export interface AbsolutePointer extends PointerBase {
+    type: "absolute";
+}
+export interface RelativePointer extends PointerBase {
+    type: "relative";
+    originUuid: ObjectId;
+}
+declare abstract class AbstractPointerBuilder {
+    readonly itinerary: ItineraryStep[];
+    child(propertyName: string): this;
+    lookup(...criterion: [string, any]): void;
+}
+declare class RelativePointerBuilder extends AbstractPointerBuilder implements RelativePointer {
+    originUuid: ObjectId;
+    readonly type = "relative";
+    constructor(originUuid: ObjectId);
+}
+declare class AbsolutePointerBuilder extends AbstractPointerBuilder implements AbsolutePointer {
+    readonly type = "absolute";
+    constructor();
+}
+export declare function pointer(fromId?: ObjectId): AbsolutePointerBuilder | RelativePointerBuilder;
+export declare const ROOT: AbsolutePointer;
+export {};
+//# sourceMappingURL=itinerary.d.ts.map

package/dist/itinerary/itinerary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"itinerary.d.ts","sourceRoot":"","sources":["../../src/itinerary/itinerary.ts"],"names":[],"mappings":"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"}

package/dist/itinerary/itinerary.js

@@ -0,0 +1,275 @@
+import stack from "./stack";
+export function constructiveItinerary(steps) {
+    const segments = [];
+    const prototypes = [];
+    for (let i = 0; i < steps.length; i += 2) {
+        const segment = steps[i];
+        const prototype = steps[i + 1];
+        switch (typeof segment) {
+            case "string":
+            case "number":
+                {
+                    const step = typeof segment === "number" ? positionStep(segment) : propertyStep(segment);
+                    switch (typeof prototype) {
+                        case "object":
+                            { // including Array
+                                segments.push(segment);
+                                prototypes.push(prototype);
+                            }
+                            break;
+                        default: {
+                            throw new Error(`Expecting array or object but got : '${typeof prototype}'`);
+                        }
+                    }
+                }
+                break;
+            default: {
+                throw new Error(`Expecting string or number but gor : '${typeof segment}'`);
+            }
+        }
+    }
+    return {
+        itinerary: itineraryOf(...segments),
+        prototypes: stack.fromArray(prototypes)
+    };
+}
+export function areSameItineraryStep(step1, step2) {
+    if (step1 == undefined || step2 == undefined) {
+        return false;
+    }
+    else if (step1.type !== step2.type) {
+        return false;
+    }
+    else {
+        switch (step1.type) {
+            case "property": return step2.type === "property" && step1.propertyName === step2.propertyName;
+            case "position": return step2.type === "position" && step1.position === step2.position;
+            case "lookup": {
+                return step2.type === "lookup"
+                    && step1.keys?.length === step2.keys?.length
+                    && step1.keys?.every(pv1 => step2.keys.some(pv2 => areSamePropertyValuePair(pv1, pv2)));
+            }
+        }
+    }
+}
+function areSamePropertyValuePair(p1, p2) {
+    return p1.propertyName === p2.propertyName
+        && p1.propertyValue === p2.propertyValue;
+}
+export function itineraryOf(...args) {
+    return args.reduce((parent, e) => {
+        const value = typeof e === 'string' ? propertyStep(e) : positionStep(e);
+        return { parent, value };
+    }, undefined);
+}
+const dataStep = propertyStep("data");
+const childrenStep = propertyStep("children");
+export function itineraryOverlay(it) {
+    return { value: dataStep, parent: itineraryOverlayInner(it) };
+}
+function itineraryOverlayInner(it) {
+    if (it === undefined) {
+        return undefined;
+    }
+    else {
+        const { value, parent } = it;
+        return { value, parent: { value: childrenStep, parent: itineraryOverlayInner(parent) } };
+    }
+}
+export function itineraryToStepArray(itinerary) {
+    let itn = itinerary;
+    const result = [];
+    while (itn !== undefined) {
+        result.push(itn.value);
+        itn = itn.parent;
+    }
+    return result.reverse();
+}
+export function propertyStep(propertyName) {
+    return { type: "property", propertyName };
+}
+export function positionStep(position) {
+    return { type: "position", position };
+}
+export function lookupStep(criteria) {
+    return { type: "lookup", keys: Object.entries(criteria).map(([k, v]) => ({ propertyName: k, propertyValue: v })) };
+}
+export function xpathFromStack(path) {
+    if (path === undefined) {
+        return ''; // TODO may need to return '.' here, to be checked
+    }
+    else {
+        const { value, parent } = path;
+        const parentXPath = xpathFromStack(parent);
+        switch (value.type) {
+            case 'property': {
+                return `${parentXPath}/${value.propertyName}`;
+            }
+            case 'position': {
+                return `${parentXPath}/*[${value.position + 1}]`;
+            }
+            case 'lookup': {
+                const predicate = value.keys.map(({ propertyName, propertyValue }) => `${propertyName}=$${propertyName}`).join(' and ');
+                return `${parentXPath}/*[${predicate}]`;
+            }
+        }
+    }
+}
+export function navigate(from, itinerary, prototype) {
+    if (from === undefined) {
+        return undefined;
+    }
+    if (itinerary === undefined) {
+        return from;
+    }
+    const { parent, value: step } = itinerary;
+    const current = navigate(from, parent, prototype?.parent);
+    return navigateStep(current, step, prototype?.value);
+}
+export function navigateStep(from, step, prototype) {
+    if (from === undefined) {
+        return undefined;
+    }
+    if (step === undefined) {
+        return from;
+    }
+    if (Array.isArray(from)) {
+        if (step.type === 'lookup') {
+            const stp = step;
+            const result = from.find(e => e !== undefined && stp.keys.every(({ propertyName, propertyValue }) => e[propertyName] === propertyValue));
+            if (result === undefined && prototype !== undefined) {
+                from.push(prototype);
+                return prototype;
+            }
+            else {
+                return result;
+            }
+        }
+        else if (step.type === 'position') {
+            const result = from[step.position];
+            if (result === undefined && prototype !== undefined) {
+                from[step.position] = prototype;
+                return prototype;
+            }
+            else {
+                return result;
+            }
+        }
+    }
+    else if (typeof from === 'object') {
+        if (step.type === 'property') {
+            const result = from === null ? undefined : from[step.propertyName];
+            if (result === undefined && prototype !== undefined && from !== null && from !== undefined) {
+                from[step.propertyName] = prototype;
+                return prototype;
+            }
+            else {
+                return result;
+            }
+        }
+    }
+    return undefined;
+}
+export function navigationDepth(from, itinerary, originalPath = xpathFromStack(itinerary)) {
+    if (from === undefined || from === null) {
+        return { value: undefined, path: '', originalPath };
+    }
+    if (itinerary === undefined) {
+        return { value: from, path: '', originalPath };
+    }
+    const { parent, value: step } = itinerary;
+    const current = navigationDepth(from, parent, originalPath);
+    if (current.value === undefined || current.value === null) {
+        return current;
+    }
+    const next = navigateStep(current.value, step);
+    if (next === undefined || next === null) {
+        return { value: current.value, path: xpathFromStack(parent), originalPath };
+    }
+    else {
+        return { value: next, path: xpathFromStack(itinerary), originalPath };
+    }
+}
+class OverlayNavigator {
+    navigate(from, itinerary) {
+        if (from === undefined) {
+            return undefined;
+        }
+        if (itinerary === undefined) {
+            return from;
+        }
+        const { parent, value: step } = itinerary;
+        const current = this.navigate(from, parent);
+        return current === undefined ? undefined : this.navigateStep(current, step);
+    }
+    navigateStep(from, step) {
+        if (from === undefined) {
+            return undefined;
+        }
+        if (step === undefined) {
+            return from;
+        }
+        if (Array.isArray(from.children)) {
+            if (step.type === 'lookup') {
+                const stp = step;
+                const result = from.children.find(e => e !== undefined && stp.keys.every(({ propertyName, propertyValue }) => e.keys?.[propertyName] === propertyValue));
+                return result;
+            }
+            else if (step.type === 'position') {
+                const result = from.children[step.position];
+                return result;
+            }
+        }
+        else if (from.children !== null && typeof from.children === 'object') {
+            if (step.type === 'property') {
+                const result = from === null ? undefined : from.children[step.propertyName];
+                return result;
+            }
+        }
+        return undefined;
+    }
+}
+export const overlayNavigator = new OverlayNavigator();
+/**
+ * Same as {navigate} but try to path missing data node using prototype parameter
+ * @param from
+ * @param itinerary
+ * @param prototype
+ */
+export function ensurePath(from, itinerary, prototype) {
+    return navigate(from, itinerary, prototype);
+}
+class AbstractPointerBuilder {
+    constructor() {
+        this.itinerary = [];
+    }
+    child(propertyName) {
+        this.itinerary.push({ type: "property", propertyName });
+        return this;
+    }
+    lookup(...criterion) {
+        criterion.forEach(([propertyName, propertyValue]) => {
+            this.itinerary.push({ type: "lookup", keys: [{ propertyName, propertyValue }] });
+        });
+    }
+}
+class RelativePointerBuilder extends AbstractPointerBuilder {
+    constructor(originUuid) {
+        super();
+        this.originUuid = originUuid;
+        this.type = "relative";
+    }
+}
+class AbsolutePointerBuilder extends AbstractPointerBuilder {
+    constructor() {
+        super();
+        this.type = "absolute";
+    }
+}
+export function pointer(fromId) {
+    if (fromId === undefined) {
+        return new AbsolutePointerBuilder();
+    }
+    return new RelativePointerBuilder(fromId);
+}
+export const ROOT = Object.freeze({ type: "absolute", itinerary: [] });

package/dist/itinerary/stack.d.ts

@@ -0,0 +1,20 @@
+export interface StackElement<T> {
+    value: T;
+    parent?: StackElement<T>;
+}
+export declare function head<T>(value: T): StackElement<T>;
+export declare function push<T>(head: StackElement<T> | undefined, value: T): StackElement<T>;
+export declare function concat<T>(tail: StackElement<T> | undefined, stack: StackElement<T> | undefined): StackElement<T> | undefined;
+export declare function fromArray<T = any>(t: T[] | undefined): StackElement<T> | undefined;
+export declare function reduce<T, R>(head: StackElement<T> | undefined, reducer: (r: R, t: T) => R, initial: R): R;
+declare function equal<T>(a: StackElement<T> | null | undefined, b: StackElement<T> | null | undefined): boolean;
+declare const stack: {
+    push: typeof push;
+    head: typeof head;
+    concat: typeof concat;
+    reduce: typeof reduce;
+    fromArray: typeof fromArray;
+    equal: typeof equal;
+};
+export default stack;
+//# sourceMappingURL=stack.d.ts.map

package/dist/itinerary/stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.d.ts","sourceRoot":"","sources":["../../src/itinerary/stack.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,KAAK,EAAG,CAAC,CAAA;IACT,MAAM,CAAC,EAAG,YAAY,CAAC,CAAC,CAAC,CAAA;CAC1B;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAG,CAAC,GAAI,YAAY,CAAC,CAAC,CAAC,CAEnD;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,EAAG,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,KAAK,EAAG,CAAC,GAAI,YAAY,CAAC,CAAC,CAAC,CAEvF;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAG,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,KAAK,EAAG,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,GAAI,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAO/H;AAED,wBAAgB,SAAS,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,EAAG,CAAC,EAAE,GAAG,SAAS,GAAI,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAEpF;AAED,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAG,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,EAAE,OAAO,EAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAG,CAAC,KAAK,CAAC,EAAE,OAAO,EAAG,CAAC,GAAI,CAAC,CAQ9G;AAED,iBAAS,KAAK,CAAC,CAAC,EAAE,CAAC,EAAC,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,EAAE,CAAC,EAAG,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,GAAI,OAAO,CAqBxG;AAED,QAAA,MAAM,KAAK;;;;;;;CAAiD,CAAA;AAE5D,eAAe,KAAK,CAAC"}

package/dist/itinerary/stack.js

@@ -0,0 +1,47 @@
+export function head(value) {
+    return { value };
+}
+export function push(head, value) {
+    return { value, parent: head };
+}
+export function concat(tail, stack) {
+    if (tail === undefined)
+        return stack;
+    if (stack === undefined)
+        return tail;
+    const { parent, value } = stack;
+    return { value, parent: concat(tail, parent) };
+}
+export function fromArray(t) {
+    return t?.reduce((acc, t) => push(acc, t), undefined);
+}
+export function reduce(head, reducer, initial) {
+    if (head === undefined) {
+        return initial;
+    }
+    const { parent, value } = head;
+    const acc = reduce(parent, reducer, initial);
+    return reducer(acc, value);
+}
+function equal(a, b) {
+    // Not equal if both are nullish
+    if (a === undefined || a === null || b === undefined || b === null) {
+        return false;
+    }
+    while (a !== undefined && b !== undefined) {
+        if (a.value !== b.value) {
+            return false;
+        }
+        a = a.parent;
+        b = b.parent;
+    }
+    // Equal if traversed all stack at both side
+    if ((a === undefined || a === null) && (b === undefined || b === null)) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+const stack = { push, head, concat, reduce, fromArray, equal };
+export default stack;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@hamak/shared-utils",
+  "version": "0.4.1",
+  "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,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amah/app-framework.git",
+    "directory": "packages/utils/shared-utils"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.es2015.json",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js",
+      "legacy": "./dist/es2015/index.js"
+    },
+    "./es2015": {
+      "import": "./dist/es2015/index.js",
+      "default": "./dist/es2015/index.js"
+    }
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "~5.4.0",
+    "vitest": "^2.0.0"
+  }
+}

package/src/core-utils-chrono.ts

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

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

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

@@ -0,0 +1,63 @@
+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();
+  });
+});