@hamak/navigation-utils 0.4.7 → 0.4.8

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@hamak/navigation-utils",
-  "version": "0.4.7",
+  "version": "0.4.8",
   "private": false,
   "type": "module",
   "description": "Navigation utilities for path manipulation and data structure navigation",
   "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/filesystem/fs-node-abstract.types.ts

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

package/src/index.ts

@@ -1,11 +0,0 @@
-// 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/src/itinerary/hyper-layer-node.ts

@@ -1,25 +0,0 @@
-export interface HyperLayerNode<T> {
-  keys?: Record<PropertyKey, any> // Keys to use for property based navigation when applicable
-  data? : T
-  children? : Record<string, HyperLayerNode<T>> | Array<HyperLayerNode<T>>
-}
-
-export function hyper<T>(data : T, children?: Record<string, HyperLayerNode<T>> | Array<HyperLayerNode<T>>) : HyperLayerNode<T> {
-  return {data, children}
-}
-
-/**
- * Utility function that create Overlay which mirror original object
- * @param o
- */
-export function hyperReflect(o : any) : HyperLayerNode<any> {
-  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/src/itinerary/itinerary.spec.ts

@@ -1,388 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  areSameItineraryStep,
-  constructiveItinerary,
-  Itinerary,
-  itineraryOf,
-  itineraryOverlay,
-  itineraryToStepArray,
-  navigate,
-  navigationDepth,
-  overlayNavigator,
-  positionStep,
-  propertyStep,
-  xpathFromStack
-} from './itinerary';
-import stack from './stack';
-import { hyperReflect } from './hyper-layer-node';
-
-interface Address {
-  street: string
-  lines: string[]
-  country: string
-}
-
-interface Person {
-  name: string
-  age?: number
-  address?: Address
-  children?: Person[]
-}
-
-describe('Navigate itinerary', () => {
-  it('should work', () => {
-    const itinerary: Itinerary = {
-      "value": {
-        "type": "property",
-        "propertyName": "schema"
-      },
-      "parent": {
-        "value": {
-          "type": "position",
-          "position": 0
-        }
-      }
-    }
-
-    const actual = navigate(sampleData(), itinerary);
-    const expected = schemaEntry1.schema
-
-    expect(actual).toBe(expected);
-  });
-
-  it('Conversion to array should work', () => {
-    const path = [0, 'schema']
-    const itinerary = itineraryOf(...path)
-    const actual = itineraryToStepArray(itinerary!);
-    const expected = path.map(e => typeof e === 'string' ? propertyStep(e) : positionStep(e))
-
-    expect(actual).toStrictEqual(expected);
-  });
-
-  it('Ensure path should work', () => {
-    const person: Person[] = [{
-      name: "Elon MUSK",
-    }]
-    const path = [0, 'address']
-    const itinerary = itineraryOf(...path)
-    const proto = { street: "Wall Street" } as Address;
-    const result = navigate(person, itinerary, stack.fromArray([proto]));
-
-    expect(result).toBe(proto);
-    expect(person[0].address).toBe(proto);
-  });
-
-  it('Deep navigation with constructiveItinerary should work', () => {
-    const person: Person[] = [{
-      name: "Guezo",
-      children: []
-    }]
-
-    const { itinerary, prototypes } = constructiveItinerary(["children", [], 0, { name: "Glélé" }, "children", [], 0, { name: "Béhanzin" }])
-    const result = navigate(person, stack.concat(itineraryOf(0), itinerary), prototypes) as Person;
-
-    expect(person[0]?.name).toBe("Guezo");
-    expect(result.name).toBe("Béhanzin");
-  });
-
-  it("Overlay navigation should work", () => {
-    const person: Person = {
-      name: "John Doe",
-      age: 40,
-      address: {
-        street: "123 Main Street",
-        lines: ["Apt 4B", "2nd Floor"],
-        country: "USA"
-      },
-      children: [
-        {
-          name: "Jane Doe",
-          age: 10,
-          address: {
-            street: "456 Maple Avenue",
-            lines: ["House 12"],
-            country: "USA"
-          }
-        },
-        {
-          name: "Jack Doe",
-          age: 8
-        }
-      ]
-    };
-
-    const personOverlay = hyperReflect(person)
-
-    const itinerary = itineraryOf("children", 0, "address", "lines", 0)
-
-    expect(navigate(person, itinerary)).toBe("House 12")
-    expect(navigate(personOverlay, itineraryOverlay(itinerary))).toBe("House 12")
-    expect(overlayNavigator.navigate(personOverlay, itinerary)?.data).toBe("House 12")
-  })
-
-  it("Overlay itinerary rewrite should work", () => {
-    const toOverlay = (...path: (string | number)[]) => {
-      return xpathFromStack(itineraryOverlay(itineraryOf(...path)))
-    }
-
-    expect(toOverlay()).toBe("/data")
-    expect(toOverlay("name")).toBe("/children/name/data")
-    expect(toOverlay("persons", 0)).toBe("/children/persons/children/*[1]/data")
-  })
-});
-
-const schemaEntry1 = {
-  "id": "schema:User",
-  "schema": {
-    "schemaNodeType": "object",
-    "operator": false,
-    "facets": {},
-    "properties": [
-      {
-        "uuid": "172302fe-29de-462a-9e27-053463b6d118",
-        "schemaNodeType": "property",
-        "facets": {},
-        "name": "uuid",
-        "valueSchema": {
-          "schemaNodeType": "scalar",
-          "operator": false,
-          "facets": {},
-          "type": "string"
-        }
-      },
-      {
-        "uuid": "733675e6-543e-4013-a071-a9a45145321b",
-        "schemaNodeType": "property",
-        "facets": {},
-        "name": "name",
-        "valueSchema": {
-          "schemaNodeType": "scalar",
-          "operator": false,
-          "facets": {},
-          "type": "string"
-        }
-      },
-      {
-        "uuid": "8376b829-459a-4b40-b2f9-71a6aea506e5",
-        "schemaNodeType": "property",
-        "facets": {},
-        "name": "firstName",
-        "valueSchema": {
-          "schemaNodeType": "scalar",
-          "operator": false,
-          "facets": {},
-          "type": "string"
-        }
-      },
-      {
-        "uuid": "3c39bfc4-90ae-4525-9366-47c7866265f3",
-        "schemaNodeType": "property",
-        "facets": {},
-        "name": "lastName",
-        "valueSchema": {
-          "schemaNodeType": "scalar",
-          "operator": false,
-          "facets": {},
-          "type": "string"
-        }
-      },
-      {
-        "uuid": "a5f05908-8a9f-4879-8dc9-f5214a6aa693",
-        "schemaNodeType": "property",
-        "facets": {},
-        "name": "age",
-        "valueSchema": {
-          "schemaNodeType": "scalar",
-          "operator": false,
-          "facets": {},
-          "type": "integer"
-        }
-      }
-    ]
-  }
-};
-
-function sampleData(): any {
-  return [
-    schemaEntry1,
-    {
-      "id": "schema:Car",
-      "schema": {
-        "schemaNodeType": "object",
-        "operator": false,
-        "facets": {},
-        "properties": [
-          {
-            "uuid": "50fa33fe-03b4-45f2-b5df-da00e742bb89",
-            "schemaNodeType": "property",
-            "facets": {},
-            "name": "uuid",
-            "valueSchema": {
-              "schemaNodeType": "scalar",
-              "operator": false,
-              "facets": {},
-              "type": "string"
-            }
-          },
-          {
-            "uuid": "6ff05784-dde5-4a70-a57b-d93cba8afb00",
-            "schemaNodeType": "property",
-            "facets": {},
-            "name": "name",
-            "valueSchema": {
-              "schemaNodeType": "scalar",
-              "operator": false,
-              "facets": {},
-              "type": "string"
-            }
-          },
-          {
-            "uuid": "a8dae1ce-a82f-46f4-a2a0-4fc177988e3c",
-            "schemaNodeType": "property",
-            "facets": {},
-            "name": "brand",
-            "valueSchema": {
-              "schemaNodeType": "scalar",
-              "operator": false,
-              "facets": {},
-              "type": "string"
-            }
-          },
-          {
-            "uuid": "85342429-673f-420e-b0d0-7e019e7bea2a",
-            "schemaNodeType": "property",
-            "facets": {},
-            "name": "color",
-            "valueSchema": {
-              "schemaNodeType": "scalar",
-              "operator": false,
-              "facets": {},
-              "type": "string"
-            }
-          }
-        ]
-      }
-    }
-  ]
-}
-
-// Unit tests for areSameItineraryStep
-describe('areSameItineraryStep', () => {
-  it('returns true for two position steps with the same position', () => {
-    expect(
-      areSameItineraryStep(positionStep(3), positionStep(3))
-    ).toBe(true);
-  });
-
-  it('returns false for two position steps with different positions', () => {
-    expect(
-      areSameItineraryStep(
-        positionStep(2),
-        positionStep(5)
-      )
-    ).toBe(false);
-  });
-
-  it('returns true for two property steps with the same propertyName', () => {
-    expect(
-      areSameItineraryStep(propertyStep('foo'), propertyStep('foo'))
-    ).toBe(true);
-  });
-
-  it('returns false for two property steps with different propertyNames', () => {
-    expect(
-      areSameItineraryStep(
-        propertyStep('foo'),
-        propertyStep('bar')
-      )
-    ).toBe(false);
-  });
-
-  it('returns false for steps of different types', () => {
-    expect(
-      areSameItineraryStep(
-        positionStep(1),
-        propertyStep('1')
-      )
-    ).toBe(false);
-  });
-
-  it('returns false if one or both steps are null or undefined', () => {
-    expect(
-      areSameItineraryStep(
-        positionStep(1),
-        null as any
-      )
-    ).toBe(false);
-    expect(
-      areSameItineraryStep(
-        undefined as any,
-        propertyStep('foo')
-      )
-    ).toBe(false);
-    expect(
-      areSameItineraryStep(
-        undefined as any,
-        undefined as any
-      )
-    ).toBe(false);
-  });
-});
-
-describe('navigationDepth with itineraryOf', () => {
-  it('should return root when itinerary is undefined', () => {
-    const obj = { a: 1 };
-    const result = navigationDepth(obj, undefined);
-    expect(result.value).toBe(obj);
-    expect(result.path).toBe('');
-  });
-
-  it('should navigate fully when path exists', () => {
-    const obj = { a: { b: { c: 42 } } };
-    const itinerary = itineraryOf('a', 'b', 'c');
-
-    const result = navigationDepth(obj, itinerary);
-    expect(result.value).toBe(42);
-    expect(result.path).toBe('/a/b/c');
-  });
-
-  it('should stop at last defined property (null)', () => {
-    const obj = { a: { b: null } };
-    const itinerary = itineraryOf('a', 'b', 'c');
-
-    const result = navigationDepth(obj, itinerary);
-    expect(result.value).toEqual({ b: null });
-    expect(result.path).toBe('/a/b');
-  });
-
-  it('should stop when root is undefined', () => {
-    const result = navigationDepth(undefined, itineraryOf('a', 'b'));
-    expect(result.value).toBeUndefined();
-    expect(result.path).toBe('');
-  });
-
-  it('should navigate inside array with position step', () => {
-    const obj = { list: [{ id: 1 }, { id: 2 }] };
-    const itinerary = itineraryOf('list', 1);
-
-    const result = navigationDepth(obj, itinerary);
-    expect(result.value).toEqual({ id: 2 });
-    expect(result.path).toBe('/list/*[2]');
-  });
-
-  it('should stop when lookup fails', () => {
-    const obj = { list: [{ id: 1 }, { id: 2 }] };
-    const lookupStep = {
-      type: 'lookup' as const,
-      keys: [{ propertyName: 'id', propertyValue: 3 }]
-    };
-    const itinerary = {
-      value: lookupStep,
-      parent: itineraryOf('list')
-    };
-
-    const result = navigationDepth(obj, itinerary);
-    expect(result.value).toEqual(obj.list);
-    expect(result.path).toBe('/list');
-  });
-});

package/src/itinerary/itinerary.ts

@@ -1,363 +0,0 @@
-import stack, {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 function constructiveItinerary(steps : Array<string | number | StepValueNodeType>) : ConstructiveItinerary {
-  const segments : Array<string | number> = []
-  const prototypes : Array<any> = []
-
-  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 : ItineraryStep | null | undefined, step2: ItineraryStep | null | undefined) : boolean {
-  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: PropertyValuePair, p2: PropertyValuePair) {
-  return p1.propertyName === p2.propertyName
-      && p1.propertyValue === p2.propertyValue
-}
-
-export function itineraryOf(... args : (string | number)[]) : Itinerary | undefined{
-  return args.reduce((parent, e) => {
-    const value = typeof e === 'string' ? propertyStep(e) : positionStep(e)
-    return {parent, value}
-  }, undefined as StackElement<ItineraryStep> | undefined)
-}
-
-const dataStep = propertyStep("data")
-const childrenStep = propertyStep("children")
-
-export function itineraryOverlay(it :  Itinerary | undefined) : Itinerary {
-  return {value:dataStep, parent:itineraryOverlayInner(it)}
-}
-
-function itineraryOverlayInner(it :  Itinerary | undefined) : Itinerary | undefined{
-  if(it === undefined){
-    return undefined
-  } else {
-    const {value, parent} = it
-    return {value, parent:{value:childrenStep, parent: itineraryOverlayInner(parent)}}
-  }
-}
-
-export function itineraryToStepArray(itinerary :Itinerary | undefined) : ItineraryStep[] {
-  let itn : Itinerary | undefined = itinerary
-  const result : ItineraryStep[] = []
-  while (itn !== undefined){
-    result.push(itn.value)
-    itn = itn.parent
-  }
-
-  return result.reverse()
-}
-
-export function propertyStep(propertyName: string) : PropertyStep {
-  return {type:"property", propertyName}
-}
-
-export function positionStep(position: number) : PositionStep {
-  return {type:"position", position}
-}
-
-export function lookupStep(criteria: Record<string, any>) : LookupStep {
-  return {type:"lookup", keys:Object.entries(criteria).map(([k, v]) => ({propertyName:k, propertyValue:v}))}
-}
-
-export function xpathFromStack(path?: StackElement<ItineraryStep>) : string{
-  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: any, itinerary : Itinerary | undefined, prototype? : StackElement<any>) : any {
-  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: any, step : ItineraryStep, prototype? : any) : any {
-  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: any,
-  itinerary: Itinerary | undefined,
-  originalPath: string = xpathFromStack(itinerary)
-): { value: any; path: string; originalPath: string } {
-  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<T>(from: HyperLayerNode<T>, itinerary : Itinerary | undefined) : HyperLayerNode<T>  | undefined{
-    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)
-  }
-
-  protected navigateStep<T>(from: HyperLayerNode<T>, step : ItineraryStep) : HyperLayerNode<T>  | undefined {
-    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: any, itinerary : Itinerary | undefined, prototype? : any) : any {
- return navigate(from, itinerary, prototype)
-}
-
-interface PointerBase {
-  type : "absolute" | "relative"
-  itinerary : ItineraryStep[]
-}
-
-export interface AbsolutePointer extends PointerBase {
-  type : "absolute"
-}
-
-export interface RelativePointer extends PointerBase {
-  type : "relative"
-  originUuid : ObjectId
-}
-
-abstract class AbstractPointerBuilder {
-  readonly itinerary : ItineraryStep[] = []
-  public child(propertyName : string){
-    this.itinerary.push({type:"property", propertyName})
-    return this
-  }
-  public lookup(...criterion : [string, any]){
-    criterion.forEach(([propertyName, propertyValue]) => {
-      this.itinerary.push({type:"lookup", keys:[{propertyName, propertyValue}]})
-    })
-  }
-}
-
-class RelativePointerBuilder extends AbstractPointerBuilder implements RelativePointer {
-  readonly type = "relative"
-  public constructor(public originUuid : ObjectId){
-    super()
-  }
-}
-
-class AbsolutePointerBuilder extends AbstractPointerBuilder implements AbsolutePointer {
-  readonly type = "absolute"
-  public constructor(){
-    super()
-  }
-}
-
-type Pointer = AbsolutePointer | RelativePointer
-
-export function pointer(fromId?: ObjectId) : AbsolutePointerBuilder | RelativePointerBuilder {
-  if(fromId === undefined){
-    return new AbsolutePointerBuilder()
-  }
-
-  return new RelativePointerBuilder(fromId)
-}
-
-export const ROOT : AbsolutePointer = Object.freeze({type:"absolute", itinerary:[]})

package/src/itinerary/stack.spec.ts

@@ -1,46 +0,0 @@
-import stack from "./stack";
-import { describe, it, expect } from 'vitest';
-
-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)
-  })
-})

package/src/itinerary/stack.ts

@@ -1,62 +0,0 @@
-export interface StackElement<T> {
-  value : T
-  parent? : StackElement<T>
-}
-
-export function head<T>(value : T) : StackElement<T> {
-  return {value}
-}
-
-export function push<T>(head : StackElement<T> | undefined, value : T) : StackElement<T> {
-  return {value, parent: head}
-}
-
-export function concat<T>(tail : StackElement<T> | undefined, stack : StackElement<T> | undefined) : StackElement<T> | undefined{
-  if(tail === undefined) return stack
-  if(stack === undefined) return tail
-
-  const {parent, value} = stack
-
-  return {value, parent:concat(tail, parent)}
-}
-
-export function fromArray<T = any>(t : T[] | undefined) : StackElement<T> | undefined {
-  return t?.reduce((acc, t) => push(acc, t), undefined as undefined | StackElement<T>)
-}
-
-export function reduce<T, R>(head : StackElement<T> | undefined, reducer : (r: R, t : T) => R, initial : R) : R {
-  if(head === undefined){
-    return initial
-  }
-
-  const {parent, value} = head
-  const acc = reduce(parent, reducer, initial)
-  return reducer(acc, value)
-}
-
-function equal<T>(a:StackElement<T> | null | undefined, b : StackElement<T> | null | undefined) : boolean {
-  // 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/src/path/pathway-resolver.ts

@@ -1,36 +0,0 @@
-import {Path, Pathway} from "./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/path/pathway.ts

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

package/tsconfig.es2015.json

@@ -1,23 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "target": "ES2015",
-    "lib": [
-      "ES2015"
-    ],
-    "outDir": "./dist/es2015",
-    "declaration": false,
-    "declarationMap": false,
-    "sourceMap": false,
-    "downlevelIteration": true,
-    "composite": false
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "**/*.test.ts"
-  ]
-}

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "lib": ["ES2020"],
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "strict": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true,
-    "declarationMap": true,
-    "allowImportingTsExtensions": false
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}