@fjell/core 4.4.0 → 4.4.1

package/dist/key/KUtils.js

@@ -0,0 +1,271 @@
+import LibLogger from '../logger.js';
+
+const logger = LibLogger.get('KUtils');
+const isItemKeyEqual = (a, b)=>{
+    logger.trace('isKeyEqual', {
+        a,
+        b
+    });
+    if (isComKey(a) && isComKey(b)) {
+        return isComKeyEqual(a, b);
+    } else if (isPriKey(a) && isPriKey(b)) {
+        if (isComKey(a) || isComKey(b)) {
+            return false;
+        } else {
+            return isPriKeyEqual(a, b);
+        }
+    } else {
+        return false;
+    }
+};
+const isPriKeyEqual = (a, b)=>{
+    logger.trace('isPriKeyEqual', {
+        a,
+        b
+    });
+    return a && b && a.pk === b.pk && a.kt === b.kt;
+};
+const isLocKeyEqual = (a, b)=>{
+    logger.trace('isLocKeyEqual', {
+        a,
+        b
+    });
+    return a && b && a.lk === b.lk && a.kt === b.kt;
+};
+const isComKeyEqual = (a, b)=>{
+    logger.trace('isComKeyEqual', {
+        a,
+        b
+    });
+    if (a && b && isPriKeyEqual({
+        kt: a.kt,
+        pk: a.pk
+    }, {
+        kt: b.kt,
+        pk: b.pk
+    })) {
+        if (a.loc.length === b.loc.length) {
+            for(let i = 0; i < a.loc.length; i++){
+                if (!isLocKeyEqual(a.loc[i], b.loc[i])) {
+                    return false;
+                }
+            }
+            return true;
+        } else {
+            return false;
+        }
+    } else {
+        return false;
+    }
+};
+const isItemKey = (key)=>{
+    logger.trace('isItemKey', {
+        key
+    });
+    return key !== undefined && (isComKey(key) || isPriKey(key));
+};
+const isComKey = (key)=>{
+    logger.trace('isComKey', {
+        key
+    });
+    return key !== undefined && key.pk !== undefined && key.kt !== undefined && key.loc !== undefined && key.loc.length > 0;
+};
+const isPriKey = (key)=>{
+    logger.trace('isPriKey', {
+        key
+    });
+    return key !== undefined && key.pk !== undefined && key.kt !== undefined && (key.loc === undefined || key.loc.length === 0);
+};
+const isLocKey = (key)=>{
+    logger.trace('isLocKey', {
+        key
+    });
+    return key !== undefined && key.lk !== undefined && key.kt !== undefined;
+};
+const generateKeyArray = (key)=>{
+    logger.trace('generateKeyArray', {
+        key
+    });
+    const keys = [];
+    if (isComKey(key) || isPriKey(key)) {
+        // console.log('it is an item key');
+        if (isComKey(key)) {
+            //  console.log('it is a composite key');
+            const comKey = key;
+            keys.push({
+                pk: comKey.pk,
+                kt: comKey.kt
+            });
+            for(let i = 0; i < comKey.loc.length; i++){
+                keys.push(comKey.loc[i]);
+            }
+        } else {
+            keys.push(key);
+        }
+    } else {
+        // console.log('is is an array, length: ' + key.length);
+        const locKeys = key;
+        for(let i = 0; i < locKeys.length; i++){
+            // console.log('Pushing a key');
+            keys.push(locKeys[i]);
+        }
+    }
+    return keys;
+};
+// TODO: Exactly the same as in ContainedItemLib
+const constructPriKey = (pk, kt)=>{
+    logger.trace('constructPriKey', {
+        pk,
+        kt
+    });
+    let pri;
+    if (typeof pk === 'string') {
+        pri = {
+            kt: kt,
+            pk: pk
+        };
+    } else {
+        pri = pk;
+    }
+    return pri;
+};
+// TODO: Exactly the same as in ContainedItemLib
+const cPK = constructPriKey;
+const toKeyTypeArray = (ik)=>{
+    logger.trace('toKeyTypeArray', {
+        ik
+    });
+    if (isComKey(ik)) {
+        const ck = ik;
+        return [
+            ck.kt,
+            ...ck.loc.map((l)=>l.kt)
+        ];
+    } else {
+        return [
+            ik.kt
+        ];
+    }
+};
+const abbrevIK = (ik)=>{
+    logger.trace('abbrevIK', {
+        ik
+    });
+    if (ik) {
+        if (isComKey(ik)) {
+            const ck = ik;
+            return `${ck.kt}:${ck.pk}:${ck.loc.map((l)=>`${l.kt}:${l.lk}`).join(',')}`;
+        } else {
+            return `${ik.kt}:${ik.pk}`;
+        }
+    } else {
+        return 'null IK';
+    }
+};
+const abbrevLKA = (keyArray)=>{
+    logger.trace('abbrevLKA', {
+        keyArray
+    });
+    if (keyArray === undefined || keyArray === null) {
+        return 'null LKA';
+    } else {
+        return keyArray.map((key)=>{
+            if (key) {
+                return `${key.kt}:${key.lk}`;
+            } else {
+                return key;
+            }
+        }).join(',');
+    }
+};
+const primaryType = (ik)=>{
+    logger.trace('primaryType', {
+        ik
+    });
+    if (isComKey(ik)) {
+        return ik.kt;
+    } else {
+        return ik.kt;
+    }
+};
+/**
+ *
+ * @param ik ItemKey to be used as a basis for a location
+ * @returns
+ */ const itemKeyToLocKeyArray = (ik)=>{
+    logger.trace('itemKeyToLocKeyArray', {
+        ik: abbrevIK(ik)
+    });
+    let lka = [];
+    if (isComKey(ik)) {
+        const ck = ik;
+        lka = [
+            {
+                kt: ck.kt,
+                lk: ck.pk
+            },
+            ...ck.loc
+        ];
+    } else {
+        const pk = ik;
+        lka = [
+            {
+                kt: pk.kt,
+                lk: pk.pk
+            }
+        ];
+    }
+    logger.trace('itemKeyToLocKeyArray Results', {
+        ik: abbrevIK(ik),
+        lka: abbrevLKA(lka)
+    });
+    return lka;
+};
+const ikToLKA = itemKeyToLocKeyArray;
+/**
+ * Sometimes you need to take a location key array and convert it to the item key that points to the containing item.
+ * @param lka A location key array
+ * @returns An item key corresponding to the containing item this location refers to.
+ */ const locKeyArrayToItemKey = (lka)=>{
+    logger.trace('locKeyArrayToItemKey', {
+        lka: abbrevLKA(lka)
+    });
+    if (lka && lka.length === 1) {
+        const priKey = cPK(lka[0].lk, lka[0].kt);
+        return priKey;
+    } else if (lka && lka.length > 1 && lka[0] !== undefined) {
+        const locs = lka.slice(1);
+        const priKey = cPK(lka[0].lk, lka[0].kt);
+        const comKey = {
+            kt: priKey.kt,
+            pk: priKey.pk,
+            loc: locs
+        };
+        return comKey;
+    } else {
+        throw new Error('locKeyArrayToItemKey: lka is undefined or empty');
+    }
+};
+// TODO: This is annoying that we have to check for '' and 'null'
+const isValidPriKey = (key)=>{
+    const valid = key !== undefined && key !== null && key.pk !== undefined && key.pk !== null && key.pk !== '' && key.pk !== 'null' && key.kt !== undefined && key.kt !== null && key.kt !== '' && key.kt !== 'null';
+    return valid;
+};
+// TODO: This is annoying that we have to check for '' and 'null'
+const isValidLocKey = (key)=>{
+    const valid = key !== undefined && key !== null && key.lk !== undefined && key.lk !== null && key.lk !== '' && key.lk !== 'null' && key.kt !== undefined && key.kt !== null && key.kt !== '' && key.kt !== 'null';
+    return valid;
+};
+const isValidLocKeyArray = (keyArray)=>{
+    return keyArray !== undefined && keyArray !== null && keyArray.every(isValidLocKey);
+};
+const isValidComKey = (key)=>{
+    return key !== undefined && key !== null && isValidPriKey(key) && isValidLocKeyArray(key.loc);
+};
+const isValidItemKey = (key)=>{
+    return isComKey(key) && isValidComKey(key) || isPriKey(key) && isValidPriKey(key);
+};
+const lkaToIK = locKeyArrayToItemKey;
+
+export { abbrevIK, abbrevLKA, cPK, constructPriKey, generateKeyArray, ikToLKA, isComKey, isComKeyEqual, isItemKey, isItemKeyEqual, isLocKey, isLocKeyEqual, isPriKey, isPriKeyEqual, isValidComKey, isValidItemKey, isValidLocKey, isValidLocKeyArray, isValidPriKey, itemKeyToLocKeyArray, lkaToIK, locKeyArrayToItemKey, primaryType, toKeyTypeArray };
+//# sourceMappingURL=KUtils.js.map

package/dist/key/KUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"KUtils.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/keys.d.ts

@@ -0,0 +1,66 @@
+export type UUID = `${string}-${string}-${string}-${string}-${string}`;
+export interface ComKey<S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> {
+    readonly kt: S;
+    readonly pk: UUID | string;
+    readonly loc: LocKeyArray<L1, L2, L3, L4, L5>;
+}
+export interface PriKey<S extends string> {
+    readonly kt: S;
+    readonly pk: UUID | string;
+}
+export interface LocKey<L extends string> {
+    readonly kt: L;
+    readonly lk: UUID | string;
+}
+export type LocKeyArray<L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> = ([L5] extends [never] ? ([L4] extends [never] ? ([L3] extends [never] ? ([L2] extends [never] ? ([L1] extends [never] ? [
+] | never : [
+    LocKey<L1>
+]) : [
+    LocKey<L1>,
+    LocKey<L2>
+]) : [
+    LocKey<L1>,
+    LocKey<L2>,
+    LocKey<L3>
+]) : [
+    LocKey<L1>,
+    LocKey<L2>,
+    LocKey<L3>,
+    LocKey<L4>
+]) : [
+    LocKey<L1>,
+    LocKey<L2>,
+    LocKey<L3>,
+    LocKey<L4>,
+    LocKey<L5>
+]);
+export type ItemTypeArray<S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> = ([L5] extends [never] ? ([L4] extends [never] ? ([L3] extends [never] ? ([L2] extends [never] ? ([L1] extends [never] ? [
+    S
+] : [
+    S,
+    L1
+]) : [
+    S,
+    L1,
+    L2
+]) : [
+    S,
+    L1,
+    L2,
+    L3
+]) : [
+    S,
+    L1,
+    L2,
+    L3,
+    L4
+]) : [
+    S,
+    L1,
+    L2,
+    L3,
+    L4,
+    L5
+]);
+export type AllItemTypeArrays<S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> = readonly [S] | readonly [S, L1] | readonly [S, L1, L2] | readonly [S, L1, L2, L3] | readonly [S, L1, L2, L3, L4] | readonly [S, L1, L2, L3, L4, L5];
+export type AllLocTypeArrays<L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> = readonly [] | readonly [L1] | readonly [L1, L2] | readonly [L1, L2, L3] | readonly [L1, L2, L3, L4] | readonly [L1, L2, L3, L4, L5];

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+declare const LibLogger: import('@fjell/logging').Logger;
+export default LibLogger;

package/dist/logger.js

@@ -0,0 +1,6 @@
+import Logging from '@fjell/logging';
+
+const LibLogger = Logging.getLogger('@fjell/core');
+
+export { LibLogger as default };
+//# sourceMappingURL=logger.js.map

package/dist/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fjell/core",
   "description": "Core Items for Fjell",
-  "version": "4.4.0",
+  "version": "4.4.1",
   "license": "Apache-2.0",
   "main": "./dist/src/index.js",
   "exports": {

package/eslint.config.mjs

@@ -1,70 +0,0 @@
-import typescriptEslint from "@typescript-eslint/eslint-plugin";
-import tsParser from "@typescript-eslint/parser";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import js from "@eslint/js";
-import { FlatCompat } from "@eslint/eslintrc";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const compat = new FlatCompat({
-  baseDirectory: __dirname,
-  recommendedConfig: js.configs.recommended,
-  allConfig: js.configs.all
-});
-
-export default [{
-  ignores: ["**/dist", "**/node_modules"],
-}, ...compat.extends("plugin:@typescript-eslint/recommended"), {
-  plugins: {
-    "@typescript-eslint": typescriptEslint,
-  },
-
-  languageOptions: {
-    parser: tsParser,
-  },
-
-  rules: {
-    "@typescript-eslint/no-unused-expressions": "off",
-    "no-console": 0,
-    "no-unused-vars": "off",
-
-    "max-len": ["error", {
-      code: 120,
-    }],
-
-    "max-depth": ["error", 4],
-    "max-params": ["error", 4],
-    "max-lines": ["error", 500],
-
-    "no-multiple-empty-lines": ["error", {
-      max: 1,
-      maxEOF: 1,
-    }],
-
-    "no-trailing-spaces": ["error", {
-      skipBlankLines: true,
-    }],
-
-    indent: ["error", 2, {
-      SwitchCase: 1,
-    }],
-
-    "sort-imports": ["error", {
-      ignoreCase: true,
-      ignoreDeclarationSort: true,
-      ignoreMemberSort: false,
-      memberSyntaxSortOrder: ["none", "all", "multiple", "single"],
-    }],
-
-    "no-var": "error",
-    "no-undefined": "error",
-    "@typescript-eslint/no-unused-vars": "error",
-    "@typescript-eslint/ban-ts-comment": "off",
-    "@typescript-eslint/no-explicit-any": "off",
-
-    "no-restricted-imports": ["error", {
-      patterns: ["..*", "src/*"],
-    }],
-  },
-}];

package/vite.config.ts

@@ -1,55 +0,0 @@
-import { defineConfig } from 'vite';
-import { VitePluginNode } from 'vite-plugin-node';
-import dts from 'vite-plugin-dts';
-import path from 'path';
-
-export default defineConfig({
-  server: {
-    port: 3000
-  },
-  plugins: [
-    ...VitePluginNode({
-      adapter: 'express',
-      appPath: './src/index.ts',
-      exportName: 'viteNodeApp',
-      tsCompiler: 'swc',
-    }),
-    // visualizer({
-    //     template: 'network',
-    //     filename: 'network.html',
-    //     projectRoot: process.cwd(),
-    // }),
-    dts({
-      entryRoot: 'src',
-      outDir: 'dist',
-      exclude: ['./tests/**/*.ts'],
-      include: ['./src/**/*.ts'],
-    }),
-  ],
-  resolve: {
-    alias: {
-      '@': path.resolve(__dirname, './src'),
-    },
-  },
-  build: {
-    target: 'esnext',
-    outDir: 'dist',
-    lib: {
-      entry: './src/index.ts',
-      formats: ['es'],
-    },
-    rollupOptions: {
-      input: 'src/index.ts',
-      output: {
-        format: 'esm',
-        entryFileNames: '[name].js',
-        preserveModules: true,
-        exports: 'named',
-      },
-    },
-    // Make sure Vite generates ESM-compatible code
-    modulePreload: false,
-    minify: false,
-    sourcemap: true
-  },
-});