@hamak/navigation-utils 0.4.0

package/dist/es2015/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 === null || t === void 0 ? void 0 : 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/dist/es2015/itinerary/stack.spec.js

@@ -0,0 +1,35 @@
+import stack from "./stack";
+import { describe, it, expect } from 'vitest';
+describe("Core util stack", () => {
+    it("fromArray should work", () => {
+        var _a, _b, _c;
+        const itinerary = stack.fromArray([1, 2, 3, 4]);
+        expect(itinerary === null || itinerary === void 0 ? void 0 : itinerary.value).toBe(4);
+        expect((_c = (_b = (_a = itinerary === null || itinerary === void 0 ? void 0 : itinerary.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent) === null || _c === void 0 ? void 0 : _c.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], []);
+        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);
+    });
+});

package/dist/es2015/path/pathway-resolver.js

@@ -0,0 +1,31 @@
+import { Pathway } from "./pathway";
+export class RecordPathwayResolver {
+    constructor(record) {
+        this.record = record;
+    }
+    resolve(path) {
+        const key = Pathway.asString(path);
+        return this.record[key];
+    }
+}
+export class EmptyPathwayResolver {
+    resolve(path) {
+        return undefined;
+    }
+}
+export class RelativePathwayResolver {
+    constructor(parentResolver, path) {
+        this.parentResolver = parentResolver;
+        this.path = path;
+        this.relativePathway = Pathway.of(path);
+    }
+    resolve(path) {
+        const pathway = Pathway.of(path);
+        if (pathway.isAbsolute()) {
+            return this.parentResolver.resolve(path);
+        }
+        else {
+            return this.parentResolver.resolve(this.relativePathway.resolve(pathway));
+        }
+    }
+}

package/dist/es2015/path/pathway.js

@@ -0,0 +1,206 @@
+/**
+ * Class representing a normalized pathway.
+ */
+export class Pathway {
+    /**
+     * 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) {
+        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.
+     */
+    static of(path) {
+        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.
+     */
+    normalizePath(path) {
+        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('/'));
+        }, [])
+            .filter(segment => segment.length > 0);
+    }
+    /**
+     * Returns the normalized path segments.
+     * @returns An array of normalized path segments.
+     */
+    getSegments() {
+        return this.segments;
+    }
+    isCurrentDir() {
+        return this.getSegments().length === 0;
+    }
+    /**
+     * Converts the normalized path segments back to a string.
+     * @returns The normalized path as a string.
+     */
+    toString() {
+        return this.isAbsolute() ? '/' + this.segments.join('/') : this.segments.join('/');
+    }
+    /**
+     * Checks if the pathway is absolute.
+     * @returns True if the pathway is absolute, false otherwise.
+     */
+    isAbsolute() {
+        return this.isAbsolutePath;
+    }
+    /**
+     * Checks if the pathway is relative.
+     * @returns True if the pathway is relative, false otherwise.
+     */
+    isRelative() {
+        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.
+     */
+    resolve(otherPath) {
+        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.
+     */
+    getParent() {
+        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.
+     */
+    getCurrentDirectory() {
+        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.
+     */
+    static ofRoot() {
+        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.
+     */
+    relativize(otherPath) {
+        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.
+     */
+    isDescendant(otherPath) {
+        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) {
+        const pathway = typeof path === "object" && !Array.isArray(path) ? path : Pathway.of(path);
+        return pathway.isRelative();
+    }
+    static asString(path) {
+        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) {
+        let name;
+        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/dist/filesystem/fs-node-abstract.types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Schema information for file content
+ */
+export type FileContentSchema = string | {
+    schemaObject: string;
+    namespace?: string;
+};
+/**
+ * Base interface for filesystem nodes (without state)
+ */
+export interface AbstractFileSystemNodeBase {
+    type: 'directory' | 'file';
+    name: string;
+}
+/**
+ * Abstract directory node (without state management)
+ */
+export interface AbstractDirectoryNode<T extends AbstractFileSystemNodeBase = AbstractFileSystemNode> extends AbstractFileSystemNodeBase {
+    type: 'directory';
+    children: Record<string, T>;
+}
+/**
+ * Abstract file node (without state management)
+ */
+export interface AbstractFileNode<T = any> extends AbstractFileSystemNodeBase {
+    type: 'file';
+    content: T;
+    schema: string | FileContentSchema;
+}
+/**
+ * Union type for abstract filesystem nodes
+ */
+export type AbstractFileSystemNode = AbstractDirectoryNode | AbstractFileNode;
+//# sourceMappingURL=fs-node-abstract.types.d.ts.map

package/dist/filesystem/fs-node-abstract.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-node-abstract.types.d.ts","sourceRoot":"","sources":["../../src/filesystem/fs-node-abstract.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAErF;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,WAAW,GAAG,MAAM,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC,SAAS,0BAA0B,GAAG,sBAAsB,CAAE,SAAQ,0BAA0B;IACtI,IAAI,EAAE,WAAW,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAA;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,0BAA0B;IAC3E,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,CAAC,CAAA;IACV,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAAA;CACnC;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,qBAAqB,GAAG,gBAAgB,CAAA"}

package/dist/filesystem/fs-node-abstract.types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from './path/pathway';
+export * from './path/pathway-resolver';
+export * from './itinerary/itinerary';
+export * from './itinerary/stack';
+export * from './itinerary/hyper-layer-node';
+export * from './filesystem/fs-node-abstract.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,yBAAyB,CAAC;AAGxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAG7C,cAAc,qCAAqC,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+// Path utilities
+export * from './path/pathway';
+export * from './path/pathway-resolver';
+// Itinerary utilities
+export * from './itinerary/itinerary';
+export * from './itinerary/stack';
+export * from './itinerary/hyper-layer-node';
+// Filesystem abstractions
+export * from './filesystem/fs-node-abstract.types';

package/dist/itinerary/hyper-layer-node.d.ts

@@ -0,0 +1,12 @@
+export interface HyperLayerNode<T> {
+    keys?: Record<PropertyKey, any>;
+    data?: T;
+    children?: Record<string, HyperLayerNode<T>> | Array<HyperLayerNode<T>>;
+}
+export declare function hyper<T>(data: T, children?: Record<string, HyperLayerNode<T>> | Array<HyperLayerNode<T>>): HyperLayerNode<T>;
+/**
+ * Utility function that create Overlay which mirror original object
+ * @param o
+ */
+export declare function hyperReflect(o: any): HyperLayerNode<any>;
+//# sourceMappingURL=hyper-layer-node.d.ts.map

package/dist/itinerary/hyper-layer-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hyper-layer-node.d.ts","sourceRoot":"","sources":["../../src/itinerary/hyper-layer-node.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,CAAA;IAC/B,IAAI,CAAC,EAAG,CAAC,CAAA;IACT,QAAQ,CAAC,EAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAA;CACzE;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,EAAG,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,GAAI,cAAc,CAAC,CAAC,CAAC,CAE9H;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAG,GAAG,GAAI,cAAc,CAAC,GAAG,CAAC,CAU1D"}

package/dist/itinerary/hyper-layer-node.js

@@ -0,0 +1,21 @@
+export function hyper(data, children) {
+    return { data, children };
+}
+/**
+ * Utility function that create Overlay which mirror original object
+ * @param o
+ */
+export function hyperReflect(o) {
+    if (o === null || o === undefined) {
+        return hyper(o);
+    }
+    else if (Array.isArray(o)) {
+        return hyper(o, o.map(e => hyperReflect(e)));
+    }
+    else if (typeof o === "object") {
+        return hyper(o, Object.entries(o).reduce((acc, [k, v]) => ({ ...acc, [k]: hyperReflect(v) }), {}));
+    }
+    else {
+        return hyper(o);
+    }
+}

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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"}