@hamak/shared-utils 0.4.1

package/src/core-utils-stack.ts

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

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

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

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

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

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

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

@@ -0,0 +1,25 @@
+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)
+  }
+}