@hamak/shared-utils 0.4.6 → 0.4.8

package/src/core-utils-registry.ts

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

package/src/core-utils-resolver.ts

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

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

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

package/src/core-utils-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/core-utils-types-hkt.ts

@@ -1,9 +0,0 @@
-export interface HKT3<Obj, Key extends PropertyKey, Value> {
-  _Obj: Obj;
-  _Key: Key;
-  _Value: Value;
-  _Result: unknown;
-}
-
-export type Apply3<F extends HKT3<any, any, any>, Obj, Key extends PropertyKey, Value> =
-  (F & { _Obj: Obj; _Key: Key; _Value: Value })["_Result"];

package/src/core-utils-types.ts

@@ -1,127 +0,0 @@
-import {Apply3, HKT3} from "./core-utils-types-hkt";
-
-export type TypedObject<T extends string = string> = {type : T}
-export type AnyFunction = (...args : any[]) => any
-
-/**
- * Intended to hold value which can be undefined.
- * It helps to know if a value (incl. undefined) is present or not.
- */
-export interface Holder<T = any>{
-  value:T
-}
-export function holder<T=any>(value : T) : Holder<T> {
-  return {value}
-}
-
-export interface GenericReason {
-  code? : string
-  message? : string
-  parameters? : Record<string, any>
-}
-
-export type GenericError = GenericReason
-
-export type ExpressionString = string
-
-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)
-  }
-}
-
-export type HyperLayerNodeHKT<T, F extends HKT3<any, any, any>, Host = never, Key extends PropertyKey = never> =
-  T extends Array<infer U> ? {
-      data?: Apply3<F, Host, Key, T>;
-      children?: HyperLayerNodeHKT<U, F, T, never>[];
-    } :
-    T extends Record<string, any> ? {
-        data?: Apply3<F, Host, Key, T>;
-        children?: {
-          [K in keyof T]?: HyperLayerNodeHKT<T[K], F, T, K>;
-        };
-      } :
-      {
-        data?: Apply3<F, Host, Key, T>;
-      };
-
-export interface OverlayNodeBase<A> {
-  type : "object" | "array" | "scalar"
-  annotation?: A
-}
-
-
-export interface ObjectOverlayNode<A> extends OverlayNodeBase<A> {
-  type : "object"
-  children : Record<string, OverlayNode<A>>
-}
-
-
-export interface ArrayOverlayNode<A> extends OverlayNodeBase<A> {
-  type : "array"
-  children : Array<OverlayNode<A>>
-}
-
-
-export interface ScalarOverlayNode<A> extends OverlayNodeBase<A> {
-  type : "scalar"
-}
-
-export type OverlayNode<A> = ObjectOverlayNode<A> | ArrayOverlayNode<A> | ScalarOverlayNode<A>
-
-export interface Annotation<A> {
-  annotation?: A;
-}
-
-export type Overlay<T, A> =
-  T extends Array<infer U> ? {
-    type: "array";
-    children: Overlay<U, A>[];
-  } & Annotation<A> :
-    T extends Record<string, any> ? {
-      type: "object";
-      children: {
-        [K in keyof T]?: Overlay<T[K], A>
-      };
-    } & Annotation<A> :
-      {
-        type: "scalar";
-      } & Annotation<A>;
-
-
-/**
- * Mainly used to prevent re-entrant navitation
- */
-export class ExplorationContext<T> {
-  constructor(readonly parent : ExplorationContext<T> | undefined, readonly values : T[]) {
-  }
-
-  explored(t : T) : boolean {
-    return this.values.includes(t)
-  }
-
-  newChild(values : T[]): ExplorationContext<T>{
-    return new ExplorationContext<T>(this, values)
-  }
-}

package/src/core-utils-validations.ts

@@ -1,36 +0,0 @@
-export interface NodeValidation {
-  type: "core:node-validation"
-  notes : ValidationNote[]
-}
-
-export interface ValidationNote {
-  uuid?: string // TODO use UUID type
-  severity : "info" | "warning" | "error"
-  key?: string
-  message?: string
-  params?: Record<string, any>
-}
-
-
-class NoteUtils {
-  add(nv : NodeValidation, ...notes : ValidationNote[]) : NodeValidation {
-    return {...(nv ?? {type: "core:node-validation"}), notes}
-  }
-  of(...notes : ValidationNote[]) : NodeValidation {
-    return {type: "core:node-validation", notes}
-  }
-  info(key?: string, message?: string, params?: Record<string, any>): ValidationNote {
-    return { severity: "info", key, message, params };
-  }
-
-  warning(key?: string, message?: string, params?: Record<string, any>): ValidationNote {
-    return { severity: "warning", key, message, params };
-  }
-
-  error(key?: string, message?: string, params?: Record<string, any>): ValidationNote {
-    return { severity: "error", key, message, params };
-  }
-}
-
-
-export const notes = new NoteUtils()

package/src/core-utils.spec.ts

@@ -1,56 +0,0 @@
-import {removeDuplicates} from './core-utils';
-import {utils} from './core-utils'
-
-describe('Stack', () => {
-  it('concat should work', () => {
-
-    expect(removeDuplicates([1,1,1])).toEqual([1]);
-    expect(removeDuplicates([1,1,2])).toEqual([1, 2]);
-    expect(removeDuplicates([1,2,1])).toEqual([1, 2]);
-    expect(removeDuplicates([])).toEqual([]);
-  });
-
-  test('Should correctly compare various cases', () => {
-    // Identical objects
-    expect(utils.deepEqual({ a: 1 }, { a: 1 })).toBe(true);
-
-    // Objects with different values
-    expect(utils.deepEqual({ a: 1, b: 2 }, { a: 1, b: 3 })).toBe(false);
-
-    // Deeply identical objects
-    expect(utils.deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } })).toBe(true);
-
-    // Deeply different objects
-    expect(utils.deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 3 } })).toBe(false);
-
-    // Identical numbers
-    expect(utils.deepEqual(1, 1)).toBe(true);
-
-    // Different numbers
-    expect(utils.deepEqual(1, 2)).toBe(false);
-
-    // Identical strings
-    expect(utils.deepEqual('hello', 'hello')).toBe(true);
-
-    // Different strings
-    expect(utils.deepEqual('hello', 'world')).toBe(false);
-
-    // Identical booleans
-    expect(utils.deepEqual(true, true)).toBe(true);
-
-    // Different booleans
-    expect(utils.deepEqual(true, false)).toBe(false);
-
-    // Null compared to null
-    expect(utils.deepEqual(null, null)).toBe(true);
-
-    // Null compared to undefined
-    expect(utils.deepEqual(null, undefined)).toBe(false);
-
-    // Null compared to object
-    expect(utils.deepEqual(null, {})).toBe(false);
-
-    // Undefined compared to object
-    expect(utils.deepEqual(undefined, {})).toBe(false);
-  });
-});

package/src/core-utils.ts

@@ -1,139 +0,0 @@
-function includes<T extends U, U> (arr : Array<T>, t : U) : t is U {
-  return arr === undefined ? false : arr.includes(t as T)
-}
-
-export function isNonNullObject(data : any) : boolean {
-  if(data ===  null || data ===  undefined){
-    return false
-  }
-
-  const dataType = typeof data
-  return dataType === 'object' && !Array.isArray(data)
-}
-
-
-function isBlank(s : string) : boolean {
-  return  s ===  null || s ===  undefined || s.trim() === ""
-}
-
-function isDefined(data : any) : boolean {
-  return  data !==  null && data !==  undefined
-}
-
-function isNotDefined(data : any) : boolean {
-  return ! isDefined(data)
-}
-
-export function isNullish(o : any) : o is (null | undefined) {
-  return o === null || o === undefined
-}
-
-export function isEmptyObject(object : Record<any, any> ) {
-  for (const property in object) {
-    return false;
-  }
-  return true;
-}
-
-export function equalSet(a : Set<unknown>, b : Set<unknown>){
-  return a.size === b.size && [...a].every((x) => b.has(x));
-}
-
-export type EqualFn<T> = (a:T, b:T) => boolean
-export const DEFAULT_EQUAL_FN : EqualFn<any> = (a, b) => a === b
-
-export function areSameDefined<T>(a : T | undefined, b: T | undefined, equalFn? : EqualFn<T>) : boolean {
-  if(a === undefined || b === undefined){
-    return false
-  }
-  if(a === null || b === null){
-    return false
-  }
-
-  return a === b || (equalFn ? equalFn(a, b) : false)
-}
-/**
- * Warning: non performant O(n2)
- * @param arr
- * @param equals
- */
-export function removeDuplicates<T>(arr : T[], equals : EqualFn<T> = DEFAULT_EQUAL_FN) : T[] {
-  return arr.filter((item, index) => arr.findIndex((e,i) => i < index && equals(item, e)) === -1)
-}
-// export function removeDuplicatesAndUndefined<T>(arr : (T|undefined)[], equals : EqualFn<T> = DEFAULT_EQUAL_FN) : T[] {
-//   return arr.filter((item, index) : item is T => item !== undefined && arr.findIndex((e,i) => i < index && equals(item, e)) === -1)
-// }
-
-function intersection<T>(o1 : Record<string, T>, o2 : Record<string, T>) {
-  return Object.keys(o1).filter({}.hasOwnProperty.bind(o2));
-}
-
-function deepEqual(obj1: any, obj2: any): boolean {
-  if (obj1 === obj2) {
-    return true;
-  }
-
-  if (obj1 === null || obj2 === null || typeof obj1 !== 'object' || typeof obj2 !== 'object') {
-    return false;
-  }
-
-  if (Array.isArray(obj1) !== Array.isArray(obj2)) {
-    return false;
-  }
-
-  const keys1 = Object.keys(obj1);
-  const keys2 = Object.keys(obj2);
-
-  if (keys1.length !== keys2.length) {
-    return false;
-  }
-
-  for (const key of keys1) {
-    if (!keys2.includes(key)) {
-      return false;
-    }
-
-    if (!deepEqual(obj1[key], obj2[key])) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-function escapeForXPath(input: string): string {
-  if (input.includes("'")) {
-    if (input.includes('"')) {
-      // Si la chaîne contient à la fois des guillemets simples et doubles
-      const parts = input.split("'");
-      return "concat(" + parts.map(part => `'${part}'`).join(", \"'\", ") + ")";
-    } else {
-      // Si la chaîne ne contient que des guillemets simples
-      return `"${input}"`;
-    }
-  } else {
-    // Si la chaîne ne contient que des guillemets doubles ou aucun guillemet
-    return `'${input}'`;
-  }
-}
-
-export type ArrayFilterFn<T> = (value:T, index : number, array : Array<T>) => boolean
-
-
-// TODO rename this function
-function cascadeFilter<T>(arr : Array<T>, fns : ArrayFilterFn<T>[]) : Array<T> {
-  if(arr.length === 0){
-    return arr
-  } else {
-    for (const filterFn of fns) {
-      const filtered = arr.filter(filterFn)
-      if(filtered.length > 0){
-        return filtered
-      }
-    }
-
-    return arr
-  }
-}
-export const utils = {includes, isNonNullObject, isEmptyObject, equalSet, isDefined, isBlank, isNotDefined, removeDuplicates, areSameDefined, intersection, deepEqual, escapeForXPath, cascadeFilter}
-

package/src/index.ts

@@ -1,34 +0,0 @@
-// Type utilities
-export * from './core-utils-types-hkt';
-export * from './core-utils-types';
-
-// Stack utilities
-export type { StackElement } from './core-utils-stack';
-export { default } from './core-utils-stack';
-
-// Core utilities
-export { utils, DEFAULT_EQUAL_FN, removeDuplicates, areSameDefined } from './core-utils';
-export type { EqualFn } from './core-utils';
-
-// Resolvers
-export * from './core-utils-resolver';
-
-// Path and navigation utilities
-export * from './core-utils-pathway';
-export * from './core-utils-pathway-resolver';
-
-// Itinerary utilities
-export * from './itinerary/itinerary';
-export * from './itinerary/stack';
-// Note: HyperLayerNode is exported from core-utils-types (more complete version with HKT)
-
-// Filesystem utilities
-export * from './core-utils-filesystem';
-
-// Other utilities
-export * from './core-utils-file';
-export * from './core-utils-registry';
-export * from './core-utils-chrono';
-export * from './core-utils-comparator';
-export * from './core-utils-fqn';
-export * from './core-utils-validations';

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