@fjell/core 4.4.2 → 4.4.4

package/src/items.ts

@@ -16,8 +16,6 @@ export type Identified<S extends string,
     key: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>;
   };
 
-export type Propertied = { [key: string]: any };
-
 /**
  * This is a generic item event, and it's designed to make sure we have the ability to define not just
  * the required fields, but also the optional fields.
@@ -48,29 +46,6 @@ export interface Deletable extends Partial<Evented> {
 
 export type ManagedEvents = Timestamped & Deletable;
 
-export type ItemProperties<
-  S extends string,
-  L1 extends string = never,
-  L2 extends string = never,
-  L3 extends string = never,
-  L4 extends string = never,
-  L5 extends string = never> =
-  Omit<Item<S, L1, L2, L3, L4, L5>, 'events' | 'key'> & {
-    events?: Evented;
-  };
-
-export type TypesProperties<
-  V extends Item<S, L1, L2, L3, L4, L5>,
-  S extends string,
-  L1 extends string = never,
-  L2 extends string = never,
-  L3 extends string = never,
-  L4 extends string = never,
-  L5 extends string = never> =
-  Omit<V, 'events' | 'key'> & {
-    events?: Evented;
-  };
-
 export type References = Record<
   string,
   ComKey<string, string | never, string | never, string | never, string | never, string | never> |
@@ -94,9 +69,43 @@ export interface Item<S extends string = never,
   L2 extends string = never,
   L3 extends string = never,
   L4 extends string = never,
-  L5 extends string = never> extends Identified<S, L1, L2, L3, L4, L5>, Propertied {
+  L5 extends string = never> extends Identified<S, L1, L2, L3, L4, L5> {
   events: ManagedEvents & Evented;
   // TODO: This is a bit of a hack to get around the fact that we don't want to pass all these generics
   aggs?: ReferenceItems;
   refs?: References;
+  [key: string]: any
 }
+
+/**
+ * Interface for properties that can be added to items
+ */
+export interface Propertied {
+  name: string;
+  value: number;
+}
+
+/**
+ * Type for item properties without the key - equivalent to Partial<Item> without the key
+ */
+export type ItemProperties<
+  S extends string = never,
+  L1 extends string = never,
+  L2 extends string = never,
+  L3 extends string = never,
+  L4 extends string = never,
+  L5 extends string = never
+> = Partial<Omit<Item<S, L1, L2, L3, L4, L5>, 'key'>>;
+
+/**
+ * Type for item properties without the key - equivalent to Partial<Item> without the key
+ * This is an alias for ItemProperties for backward compatibility
+ */
+export type TypesProperties<
+  S extends string = never,
+  L1 extends string = never,
+  L2 extends string = never,
+  L3 extends string = never,
+  L4 extends string = never,
+  L5 extends string = never
+> = Partial<Omit<Item<S, L1, L2, L3, L4, L5>, 'key'>>;

package/src/key/KUtils.ts

@@ -23,7 +23,7 @@ export const isItemKeyEqual = <
   if (isComKey(a) && isComKey(b)) {
     return isComKeyEqual(a as ComKey<S, L1, L2, L3, L4, L5>, b as ComKey<S, L1, L2, L3, L4, L5>);
   } else if (isPriKey(a) && isPriKey(b)) {
-    if(isComKey(a) || isComKey(b)) {
+    if (isComKey(a) || isComKey(b)) {
       return false;
     } else {
       return isPriKeyEqual(a as PriKey<S>, b as PriKey<S>);
@@ -163,7 +163,7 @@ export const toKeyTypeArray = <
   logger.trace('toKeyTypeArray', { ik });
   if (isComKey(ik)) {
     const ck = ik as ComKey<S, L1, L2, L3, L4, L5>;
-    return [ck.kt, ...ck.loc.map((l : LocKey<L1 | L2 | L3 | L4 | L5>) => l.kt)];
+    return [ck.kt, ...ck.loc.map((l: LocKey<L1 | L2 | L3 | L4 | L5>) => l.kt)];
   } else {
     return [(ik as PriKey<S>).kt];
   }
@@ -178,10 +178,10 @@ export const abbrevIK = <
   L5 extends string = never
 >(ik: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>): string => {
   logger.trace('abbrevIK', { ik });
-  if(ik) {
+  if (ik) {
     if (isComKey(ik)) {
       const ck = ik as ComKey<S, L1, L2, L3, L4, L5>;
-      return `${ck.kt}:${ck.pk}:${ck.loc.map((l : LocKey<L1 | L2 | L3 | L4 | L5>) => `${l.kt}:${l.lk}`).join(',')}`;
+      return `${ck.kt}:${ck.pk}:${ck.loc.map((l: LocKey<L1 | L2 | L3 | L4 | L5>) => `${l.kt}:${l.lk}`).join(',')}`;
     } else {
       return `${(ik as PriKey<S>).kt}:${(ik as PriKey<S>).pk}`;
     }
@@ -228,10 +228,10 @@ export const primaryType = <
 }
 
 /**
- *
- * @param ik ItemKey to be used as a basis for a location
- * @returns
- */
+   *
+   * @param ik ItemKey to be used as a basis for a location
+   * @returns
+   */
 export const itemKeyToLocKeyArray =
   <
     S extends string,
@@ -257,10 +257,10 @@ export const itemKeyToLocKeyArray =
 export 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.
- */
+   * 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.
+   */
 export const locKeyArrayToItemKey =
   <
     L1 extends string,
@@ -272,7 +272,7 @@ export const locKeyArrayToItemKey =
     PriKey<L1> | ComKey<L1, L2, L3, L4, L5> => {
     logger.trace('locKeyArrayToItemKey', { lka: abbrevLKA(lka as Array<LocKey<L1 | L2 | L3 | L4 | L5>>) });
 
-    if(lka && lka.length === 1) {
+    if (lka && lka.length === 1) {
       const priKey = cPK(lka[0].lk, lka[0].kt);
       return priKey as PriKey<L1>;
     } else if (lka && lka.length > 1 && lka[0] !== undefined) {

package/vitest.config.ts

@@ -0,0 +1,37 @@
+import { defineConfig } from 'vitest/config';
+import * as path from 'path';
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      all: true,
+      include: ['src/**/*.{ts,tsx}'],
+      exclude: [
+        'src/index.ts',
+        'tests/**',
+        '**/*.d.ts',
+        'node_modules/**',
+        'dist/**',
+      ],
+      reportsDirectory: './coverage',
+      reporter: ['text', 'html', 'clover', 'json'],
+      thresholds: {
+        global: {
+          branches: 91,
+          functions: 100,
+          lines: 98,
+          statements: 98,
+        },
+      },
+    },
+  },
+});

package/dist/AItemService.js.map

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

package/dist/dictionary.js.map

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

package/dist/item/IFactory.js.map

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

package/dist/item/IQFactory.js.map

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

package/dist/item/IQUtils.js.map

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

package/dist/item/IUtils.js

@@ -1,77 +0,0 @@
-import { toKeyTypeArray, isPriKey, isComKey } from '../key/KUtils.js';
-import LibLogger from '../logger.js';
-
-const logger = LibLogger.get('IUtils');
-const validatePK = (input, pkType)=>{
-    logger.trace('Checking Return Type', {
-        input
-    });
-    if (Array.isArray(input)) {
-        const itemArray = input;
-        return itemArray.map((item)=>validatePK(item, pkType));
-    } else {
-        const item = input;
-        if (item) {
-            if (item.key) {
-                const keyTypeArray = toKeyTypeArray(item.key);
-                const match = keyTypeArray[0] === pkType;
-                if (!match) {
-                    logger.error('Key Type Array Mismatch', {
-                        keyTypeArray,
-                        pkType
-                    });
-                    throw new Error('Item does not have the correct primary key type');
-                } else {
-                    return item;
-                }
-            } else {
-                logger.error('Validating PK, Item does not have a key', {
-                    item
-                });
-                throw new Error('Validating PK, Item does not have a key');
-            }
-        } else {
-            logger.error('Validating PK, Item is undefined', {
-                item
-            });
-            throw new Error('Validating PK, Item is undefined');
-        }
-    }
-};
-const validateKeys = (item, keyTypes)=>{
-    logger.trace('Checking Return Type', {
-        item
-    });
-    if (item) {
-        if (item.key) {
-            const keyTypeArray = toKeyTypeArray(item.key);
-            if (keyTypeArray.length !== keyTypes.length) {
-                throw new Error('Item does not have the correct number of keys');
-            } else {
-                const match = JSON.stringify(keyTypeArray) === JSON.stringify(keyTypes);
-                if (!match) {
-                    logger.error('Key Type Array Mismatch', {
-                        keyTypeArray,
-                        thisKeyTypes: keyTypes
-                    });
-                    throw new Error('Item does not have the correct key types');
-                } else {
-                    return item;
-                }
-            }
-        } else {
-            throw new Error('validating keys, item does not have a key: ' + JSON.stringify(item));
-        }
-    } else {
-        throw new Error('validating keys, item is undefined');
-    }
-};
-const isPriItem = (item)=>{
-    return item && item.key ? isPriKey(item.key) : false;
-};
-const isComItem = (item)=>{
-    return item && item.key ? isComKey(item.key) : false;
-};
-
-export { isComItem, isPriItem, validateKeys, validatePK };
-//# sourceMappingURL=IUtils.js.map

package/dist/item/IUtils.js.map

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

package/dist/item/ItemQuery.js.map

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

package/dist/key/KUtils.js.map

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

package/dist/logger.js.map

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