Add GitHub Actions workflow for tag creation and update utility functions

- Introduced a new workflow to automate the creation of tags and pull requests on the main branch.
- Modified `filterArrayByKeyValue` to return false for empty array values.
- Enhanced `getKeyValue` to handle nested keys more robustly and prevent returning empty arrays.
- Updated `package.json` to include additional keywords and repository type.

Author: Feresaul

.github/workflows/npm-publish.yml

@@ -0,0 +1,30 @@
+name: Node.js Package
+
+on:
+    release:
+        types: [created]
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+            - uses: actions/setup-node@v4
+              with:
+                  node-version: 20
+            - run: npm ci
+            #- run: npm test
+
+    publish-npm:
+        needs: build
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v4
+            - uses: actions/setup-node@v4
+              with:
+                  node-version: 20
+                  registry-url: https://registry.npmjs.org/
+            - run: npm ci
+            - run: npm publish
+              env:
+                  NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

.github/workflows/tag-creation.yml

@@ -0,0 +1,38 @@
+name: 'Create New Tag'
+on:
+    push:
+        branches:
+            - main
+
+jobs:
+    create-new-tag:
+        runs-on: ubuntu-24.04
+        timeout-minutes: 5
+        steps:
+            - uses: actions/checkout@v4
+
+            - name: Git Config
+              run: |
+                  git config --global user.name "${{ vars.USERNAME }}"
+                  git config --global user.email "${{ vars.EMAIL }}"
+
+            - name: Create New Branch
+              run: |
+                  git pull
+                  git checkout -b newTag
+
+            - name: App Version
+              run: npm version patch
+
+            - name: Commit Changes
+              run: |
+                  git show
+                  git push origin newTag
+                  git push --tags
+
+            - name: Create Pull Request
+              run: |
+                  gh pr create -B main -H newTag --title 'Tag Creation' --body "New tag created"
+                  gh pr merge newTag --squash --delete-branch --admin
+              env:
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

bun.lock

@@ -1,5 +1,5 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 type Primitive = number | string | boolean | null | undefined;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type TObject = Record<string, any>;
 
 /**
@@ -15,26 +15,10 @@ export type KeyOf<T extends TObject> = keyof {
               | (T[K] extends Array<infer U>
                     ? U extends Primitive
                         ? `${K}.${number}`
-                        : `${K}.${number}.${KeyOf<T[K][number]>}`
-                    : `${K}.${KeyOf<T[K]>}`)
-        : never]: unknown;
-};
-
-/**
- * Represents the keys of an object, including nested objects and arrays,
- * but ignores the positions of arrays.
- * This type is useful for creating dynamic forms or validating object structures.
- */
-export type SimpleKeyOf<T extends TObject> = keyof {
-    [K in keyof T as T[K] extends Primitive
-        ? K
-        : K extends string
-        ?
-              | K
-              | (T[K] extends Array<infer U>
-                    ? U extends Primitive
-                        ? never
-                        : `[${K}].${KeyOf<T[K][number]>}`
+                        :
+                              | `${K}.${number}`
+                              | `[${K}].${KeyOf<T[K][number]>}`
+                              | `${K}.${number}.${KeyOf<T[K][number]>}`
                     : `${K}.${KeyOf<T[K]>}`)
         : never]: unknown;
 };
@@ -50,24 +34,9 @@ export type DeepKeyOf<T extends TObject> = keyof {
         ? T[K] extends Array<infer U>
             ? U extends Primitive
                 ? K
-                : `${K}.${number}.${DeepKeyOf<T[K][number]>}`
-            : `${K}.${DeepKeyOf<T[K]>}`
-        : never]: unknown;
-};
-
-/**
- * Represents the deepest keys of an object, including nested objects and arrays,
- * but ignores the positions of arrays.
- * This type is useful for creating dynamic forms or validating object structures.
- */
-export type SimpleDeepKeyOf<T extends TObject> = keyof {
-    [K in keyof T as T[K] extends Primitive
-        ? K
-        : K extends string
-        ? T[K] extends Array<infer U>
-            ? U extends Primitive
-                ? K
-                : `[${K}].${DeepKeyOf<T[K][number]>}`
+                :
+                      | `[${K}].${DeepKeyOf<T[K][number]>}`
+                      | `${K}.${number}.${DeepKeyOf<T[K][number]>}`
             : `${K}.${DeepKeyOf<T[K]>}`
         : never]: unknown;
 };

lib/types.ts

@@ -18,7 +18,7 @@ export const filterArrayByKeyValue = <T extends TObject>(
     return list.filter((item) => {
         if (Array.isArray(value)) {
             if (value.length === 0) {
-                return true;
+                return false;
             }
             return value.some((val) => val === getKeyValue(item, key));
         }

lib/utils/filter.ts

@@ -11,17 +11,32 @@ export const getKeyValue = <T extends TObject>(
     object: T,
     key: KeyOf<T>
 ): any => {
-    const subKeys = (key as string).split('.');
+    const subKeys = (key as string)
+        .split('.')
+        .map((key) => key.replace(/[[\]]/g, ''));
     // Initialize the value with the object
     let value: any = object;
 
+    // If the object is an array, return undefined
+    // This is to prevent the function from returning an array empty objects
+    if (Array.isArray(object)) {
+        return undefined;
+    }
+
     // Iterate over the subKeys to get the nested value
     subKeys.forEach((key) => {
-        value = Array.isArray(value)
-            ? value.map((item) => item?.[key])
-            : value?.[key];
+        if (!Array.isArray(value)) {
+            value = value?.[key];
+            return;
+        }
+        // If the key is a number, get the value at that index
+        if (Number.isSafeInteger(Number(key))) {
+            value = value?.[Number(key)];
+            return;
+        }
+        value = value.map((item) => item?.[key]);
     });
 
-    // Return the deepest value for the desired key
+    // Return the value for the desired key
     return value;
 };