@hamak/shared-utils 0.4.1

package/dist/core-utils.js

@@ -0,0 +1,113 @@
+function includes(arr, t) {
+    return arr === undefined ? false : arr.includes(t);
+}
+export function isNonNullObject(data) {
+    if (data === null || data === undefined) {
+        return false;
+    }
+    const dataType = typeof data;
+    return dataType === 'object' && !Array.isArray(data);
+}
+function isBlank(s) {
+    return s === null || s === undefined || s.trim() === "";
+}
+function isDefined(data) {
+    return data !== null && data !== undefined;
+}
+function isNotDefined(data) {
+    return !isDefined(data);
+}
+export function isNullish(o) {
+    return o === null || o === undefined;
+}
+export function isEmptyObject(object) {
+    for (const property in object) {
+        return false;
+    }
+    return true;
+}
+export function equalSet(a, b) {
+    return a.size === b.size && [...a].every((x) => b.has(x));
+}
+export const DEFAULT_EQUAL_FN = (a, b) => a === b;
+export function areSameDefined(a, b, equalFn) {
+    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(arr, equals = DEFAULT_EQUAL_FN) {
+    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(o1, o2) {
+    return Object.keys(o1).filter({}.hasOwnProperty.bind(o2));
+}
+function deepEqual(obj1, obj2) {
+    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) {
+    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}'`;
+    }
+}
+// TODO rename this function
+function cascadeFilter(arr, fns) {
+    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/dist/es2015/core-utils-chrono.js

@@ -0,0 +1,16 @@
+export class Chronometre {
+    constructor() {
+        this.start = Date.now();
+    }
+    duration() {
+        return Date.now() - this.start;
+    }
+    restart() {
+        const d = this.duration();
+        this.start = Date.now();
+        return d;
+    }
+}
+export function chronometre() {
+    return new Chronometre();
+}

package/dist/es2015/core-utils-comparator.js

@@ -0,0 +1,22 @@
+export function reverseOrder(compareFn) {
+    return (a, b, fns) => -compareFn(a, b, fns);
+}
+export function compare(a, b, ...fns) {
+    if (fns.length === 0) {
+        if (typeof a === "number" && typeof b === "number") {
+            fns = [(x) => x];
+        }
+        else {
+            throw new Error(`Expecting at least one weight function when arguments are not numbers`);
+        }
+    }
+    for (const weightFn of fns) {
+        const aWeight = weightFn(a);
+        const bWeight = weightFn(b);
+        if (aWeight != bWeight) {
+            return a < b ? -1 : 1;
+        }
+    }
+    return 0;
+}
+export const compareDesc = reverseOrder(compare);

package/dist/es2015/core-utils-file.js

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

package/dist/es2015/core-utils-filesystem.js

@@ -0,0 +1,157 @@
+import { Pathway } from './core-utils-pathway';
+export function fileSystemNodeInitialState(contentPresent = true) {
+    return {
+        contentLoaded: contentPresent,
+        contentLoading: false,
+        contentLoadError: undefined,
+        contentHistory: [],
+        extensionStates: {}
+    };
+}
+function isRoot(node) {
+    switch (node.type) {
+        case "directory": {
+            return node.name === null || node.name === undefined || node.name.trim() === "" || node.name.trim() === "/";
+        }
+        case "file": {
+            return false;
+        }
+    }
+}
+export class DirectoryNodePathwayResolver {
+    constructor(root) {
+        this.root = root;
+    }
+    resolve(path) {
+        return fsutils.resolveFileNode(this.root, path);
+    }
+    changeDIr(path) {
+        const fileNode = this.resolve(path);
+        if (fileNode === undefined) {
+            throw new Error(`No such directory: ${Pathway.asString(path)}`);
+        }
+        else {
+            switch (fileNode.type) {
+                case "directory": return new DirectoryNodePathwayResolver(fileNode);
+                case "file": throw new Error(`Path is not directory: ${Pathway.asString(path)}`);
+            }
+        }
+    }
+}
+class FilesystemUtil {
+    createRootDir(children, state = fileSystemNodeInitialState()) {
+        return this.createDir("", children, state);
+    }
+    createDir(name, children, state = fileSystemNodeInitialState()) {
+        return {
+            type: "directory", name, state,
+            children: children.reduce((acc, child) => (Object.assign(Object.assign({}, acc), { [child.name]: child })), {})
+        };
+    }
+    createDirs(path, children, state = fileSystemNodeInitialState()) {
+        const pathway = Pathway.of(path);
+        const dir = pathway.getSegments().reverse().reduce((acc, segment) => {
+            return this.createDir(segment, acc === undefined ? children : [acc]);
+        }, undefined);
+        if (dir === undefined) {
+            throw new Error(`Unable de create dir '${path}'`);
+        }
+        return pathway.isAbsolute() ? this.createRootDir([dir]) : dir;
+    }
+    createFile(name, content, schema = "xs:any", state = fileSystemNodeInitialState()) {
+        return { type: "file", name, content, schema, state };
+    }
+    resolveFileNode(fromDir, path) {
+        if (fromDir === undefined) {
+            return undefined;
+        }
+        const pathway = Pathway.of(path);
+        if (pathway.isAbsolute() && !isRoot(fromDir)) {
+            return undefined;
+        }
+        const result = pathway.getSegments().reduce((acc, segment) => {
+            var _a;
+            if (acc === undefined) {
+                return undefined;
+            }
+            else {
+                switch (acc.type) {
+                    case "directory":
+                        {
+                            return (_a = acc.children) === null || _a === void 0 ? void 0 : _a[segment];
+                        }
+                        break;
+                    case "file":
+                        {
+                            return undefined;
+                        }
+                        break;
+                    default: {
+                        return undefined;
+                    }
+                }
+            }
+        }, fromDir);
+        return result;
+    }
+    asFile(fsn) {
+        return (fsn === null || fsn === void 0 ? void 0 : fsn.type) === "file" ? fsn : undefined;
+    }
+    asDirectory(fsn) {
+        return (fsn === null || fsn === void 0 ? void 0 : fsn.type) === "directory" ? fsn : undefined;
+    }
+    resolveDescendent(fromDir, path) {
+        const pathway = Pathway.of(path);
+        return pathway.isCurrentDir() ? undefined : this.resolveFileNode(fromDir, pathway);
+    }
+    /**
+     * Set a file node content a specified location. It create intermediary directories and target if missed location.
+     * @param fromDir
+     * @param path
+     * @param content
+     * @param schema
+     * @param state
+     */
+    createDescendent(fromDir, path, content, schema = "xs:any", state = fileSystemNodeInitialState(), override = false) {
+        if (!fromDir)
+            return undefined;
+        const pathway = Pathway.of(path);
+        if (pathway.isCurrentDir())
+            return undefined;
+        const segments = pathway.getSegments();
+        if (segments.length === 0)
+            return undefined;
+        if (fromDir.type !== "directory") {
+            throw new Error("Cannot create descendent on a non-directory node.");
+        }
+        let currentDir = fromDir;
+        for (let i = 0; i < segments.length - 1; i++) {
+            const segment = segments[i];
+            let nextNode = currentDir.children[segment];
+            if (!nextNode) {
+                // Create intermediate directory
+                const newDir = this.createDir(segment, []);
+                currentDir.children[segment] = newDir;
+                nextNode = newDir;
+            }
+            if (nextNode.type !== "directory") {
+                throw new Error(`Path conflict: '${segment}' is a file, expected a directory.`);
+            }
+            currentDir = nextNode;
+        }
+        const fileName = segments[segments.length - 1];
+        const existingNode = currentDir.children[fileName];
+        if (existingNode) {
+            if (existingNode.type !== "file") {
+                throw new Error(`Path conflict: '${fileName}' exists and is not a file.`);
+            }
+            if (!override) {
+                throw new Error(`File '${fileName}' already exists and override is disabled.`);
+            }
+        }
+        const fileNode = this.createFile(fileName, content, schema, state);
+        currentDir.children[fileName] = fileNode;
+        return fileNode;
+    }
+}
+export const fsutils = new FilesystemUtil();

package/dist/es2015/core-utils-fqn.js

@@ -0,0 +1,19 @@
+/**
+ * Unresolved qualified name by either namespace of prefix
+ */
+export class LexicalQualifiedName {
+    constructor(namespace, prefix, name) {
+        this.namespace = namespace;
+        this.prefix = prefix;
+        this.name = name;
+    }
+    isEqualTo(other) {
+        if ((this.name === undefined && other.name === undefined)
+            || (this.name === null && other.name === null)) {
+            return false;
+        }
+        else {
+            return this.namespace === other.namespace && this.prefix === other.prefix && this.name === other.name;
+        }
+    }
+}

package/dist/es2015/core-utils-pathway-resolver.js

@@ -0,0 +1,31 @@
+import { Pathway } from "./core-utils-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/core-utils-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/es2015/core-utils-registry.js

@@ -0,0 +1,22 @@
+export class SimpleRegistry {
+    constructor() {
+        this.records = new Map();
+    }
+    resolve(namespace, prefix, variableName) {
+        if (prefix !== undefined) {
+            throw new Error(`Not support namespace prefix for name resolution : '${prefix}'`);
+        }
+        else {
+            const record = this.records.get(namespace);
+            return record === null || record === void 0 ? void 0 : record[variableName];
+        }
+    }
+    register(namespace, variableName, t) {
+        let namespaceRecord = this.records.get(namespace);
+        if (namespaceRecord === undefined) {
+            namespaceRecord = {};
+            this.records.set(namespace, namespaceRecord);
+        }
+        namespaceRecord[variableName] = t;
+    }
+}

package/dist/es2015/core-utils-resolver.js

@@ -0,0 +1,68 @@
+export class RecordResolver {
+    constructor(variables, parent) {
+        this.variables = variables;
+        this.parent = parent;
+    }
+    resolve(namespace, prefix, variableName) {
+        var _a, _b;
+        return (_a = this.variables[variableName]) !== null && _a !== void 0 ? _a : (_b = this.parent) === null || _b === void 0 ? void 0 : _b.resolve(undefined, undefined, variableName);
+    }
+}
+export class QualifiedNameResolverImpl {
+    constructor(ignoreNs = false) {
+        this.ignoreNs = ignoreNs;
+        this.entries = new Map();
+    }
+    resolve(namespace, prefix, name) {
+        var _a;
+        if (!this.ignoreNs && namespace !== undefined && namespace !== null) {
+            throw new Error(`Not support namespace URI but passed as parameter: ${namespace}`);
+        }
+        return (_a = this.entries.get(namespace)) === null || _a === void 0 ? void 0 : _a.get(name);
+    }
+    setEntries(prefix, entries) {
+        const prefixEntry = this.getOrCreatePrefixEntry(prefix);
+        Object.entries(entries).forEach(([k, v]) => prefixEntry.set(k, v));
+    }
+    setEntry(prefix, name, entry) {
+        const prefixEntry = this.getOrCreatePrefixEntry(prefix);
+        prefixEntry.set(name, entry);
+    }
+    getOrCreatePrefixEntry(prefix) {
+        let prefixEntry = this.entries.get(prefix);
+        if (prefixEntry === undefined) {
+            prefixEntry = new Map();
+            this.entries.set(prefix, prefixEntry);
+        }
+        return prefixEntry;
+    }
+}
+export class SimpleResolver {
+    constructor(parent, namespace, variableName, variableValue) {
+        this.parent = parent;
+        this.namespace = namespace;
+        this.variableName = variableName;
+        this.variableValue = variableValue;
+    }
+    resolve(namespace, prefix, variableName) {
+        var _a;
+        if (this.namespace === namespace && this.variableName === variableName) {
+            return this.variableValue;
+        }
+        return (_a = this.parent) === null || _a === void 0 ? void 0 : _a.resolve(namespace, prefix, variableName);
+    }
+}
+export class ChainedResolver {
+    constructor(resolvers) {
+        this.resolvers = resolvers;
+    }
+    resolve(namespace, prefix, variableName) {
+        for (const resolver of this.resolvers) {
+            const s = resolver.resolve(namespace, prefix, variableName);
+            if (s !== undefined) {
+                return s;
+            }
+        }
+        return undefined;
+    }
+}