@stonyx/utils 0.1.0 → 0.1.1

package/.github/workflows/ci.yml

@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  pull_request:
+    branches:
+      - dev
+      - main
+
+concurrency:
+  group: ci-${{ github.head_ref || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 22.18.0
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test

package/README.md

@@ -1,5 +1,7 @@
 # stonyx-utils
 
+# TODO: Generate documentation for all utils
+
 ## Running the test suite
 ```
 npm test
@@ -27,3 +29,6 @@ The File utils wrap the `path` and `fs` library to allow consuming classes to ma
 | `rawName` | **Boolean** | *false* | When set to true, `forEachFileImport` will not convert the file name to be camelCase and leave it raw instead |
 | `ignoreAccessFailure` | **Boolean** | *false* | When set to true, failure to load directory will be ignored |
 
+## License
+
+Apache — do what you want, just keep attribution.

package/package.json

@@ -3,7 +3,7 @@
   "keywords": [
     "stonyx-module"
   ],
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Utils module for Stonyx Framework",
   "type": "module",
   "exports": {
@@ -24,5 +24,6 @@
   "devDependencies": {
     "fs": "^0.0.1-security",
     "qunit": "^2.24.1"
-  }
+  },
+  "dependencies": {}
 }

package/src/file.js

@@ -4,20 +4,23 @@ import { objToJson } from '@stonyx/utils/object';
 import { promises as fsp } from 'fs';
 import path from 'path';
 
-export async function createFile(filePath, data, { json }) {
+export async function createFile(filePath, data, options={}) {
   try {
-    await fsp.writeFile(filePath, json ? objToJson(data) : data, 'utf8');
+    filePath = path.resolve(filePath);
+
+    await createDirectory(path.dirname(filePath));
+    await fsp.writeFile(filePath, options.json ? objToJson(data) : data, 'utf8');
   } catch (error) {
     throw new Error(error);
   }
 }
 
-export async function updateFile(filePath, data, { json }) {
+export async function updateFile(filePath, data, options={}) {
   try {
     await fsp.access(filePath);
 
     const swapFile = `${filePath}.temp-${getTimestamp()}`;
-    await fsp.writeFile(swapFile, json ? objToJson(data) : data);
+    await fsp.writeFile(swapFile, options.json ? objToJson(data) : data);
     await fsp.rename(swapFile, filePath);
   } catch (error) {
     
@@ -25,15 +28,40 @@ export async function updateFile(filePath, data, { json }) {
   }
 }
 
-export async function readFile(filePath, { json, missingFileCallback }) {
+export async function copyFile(sourcePath, targetPath, options={}) {
+  try {
+    sourcePath = path.resolve(sourcePath);
+    targetPath = path.resolve(targetPath);
+    await fsp.access(sourcePath);
+  } catch (error) {
+    throw new Error(error);
+  }
+
+  try {
+    await fsp.access(targetPath);
+    if (!options.overwrite) return false;
+  } catch {}
+
+  try {
+    await fsp.copyFile(sourcePath, targetPath);
+  } catch (error) {
+    throw new Error(error);
+  }
+
+  return true;
+}
+
+export async function readFile(filePath, options={}) {
   try {
     filePath = path.resolve(filePath);
     
     await fsp.access(filePath);
     const fileData = await fsp.readFile(filePath, 'utf8');
 
-    return json ? JSON.parse(fileData) : fileData;
+    return options.json ? JSON.parse(fileData) : fileData;
   } catch (error) {
+    const { missingFileCallback } = options;
+
     if (error.code === 'ENOENT' && missingFileCallback) {
       return missingFileCallback(filePath);
     }
@@ -90,3 +118,13 @@ export async function forEachFileImport(dir, callback, options={}) {
     callback(output, { name, stats, path: filePath });
   }
 }
+
+export async function fileExists(filePath) {
+  try {
+    filePath = path.resolve(filePath);
+    await fsp.access(filePath);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}

package/src/object.js

@@ -6,42 +6,34 @@ export function objToJson(obj) {
   return JSON.stringify(obj);
 }
 
-export function mergeObject(obj1, obj2) {
+export function makeArray(obj) {
+  return Array.isArray(obj) ? obj : [obj];
+}
+
+export function mergeObject(obj1, obj2, options={}) {
   if (Array.isArray(obj1) || Array.isArray(obj2)) throw new Error('Cannot merge arrays.');
-  if (typeof obj1 !== 'object' || obj1 === null) return structuredClone(obj2);
-  if (typeof obj2 !== 'object' || obj2 === null) return structuredClone(obj1);
+
+  if (obj1 === null || typeof obj1 !== 'object') return cloneShallow(obj2);
+  if (obj2 === null || typeof obj2 !== 'object') return cloneShallow(obj1);
 
   const result = {};
-  const keys = new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
 
-  for (const key of keys) {
+  for (const key of Object.keys(obj1))  result[key] = cloneShallow(obj1[key]);
+  for (const key of Object.keys(obj2)) {
+    if (options.ignoreNewKeys && !(key in obj1)) continue;
+
     const val1 = obj1[key];
     const val2 = obj2[key];
-
-    if (val2 === undefined) {
-      result[key] = structuredClone(val1);
-    } else if (val1 === undefined) {
-      result[key] = structuredClone(val2);
-    } else if (
-      typeof val1 === 'object' &&
-      typeof val2 === 'object' &&
-      val1 !== null &&
-      val2 !== null &&
-      !Array.isArray(val1) &&
-      !Array.isArray(val2)
-    ) {
-      result[key] = mergeObject(val1, val2);
-    } else {
-      result[key] = structuredClone(val2);
-    }
+    const shouldMerge = val1 && val2 && typeof val1 === 'object' && typeof val2 === 'object' && !Array.isArray(val1) && !Array.isArray(val2);
+    result[key] = shouldMerge ? mergeObject(val1, val2, options) : cloneShallow(val2);
+    
   }
 
   return result;
 }
 
-export function makeArray(value) {
-  if (Array.isArray(value)) return value;
-  if (value === null || value === undefined) return [];
-
-  return [value];
+function cloneShallow(value) {
+  if (Array.isArray(value)) return value.slice();
+  if (value && typeof value === 'object') return { ...value };
+  return value;
 }

package/.nvmrc

@@ -1 +0,0 @@
-v22.18.0

package/test/unit/object-test.js

@@ -1,32 +0,0 @@
-import Qunit from 'qunit';
-import { mergeObject } from '@stonyx/utils/object';
-
-const { module, test } = Qunit;
-
-module('[Unit] Object', function() {
-  test('mergeObject works as expected', async function(assert) {
-    assert.deepEqual(
-      mergeObject({ a: 1, b: 2 }, { c: 3 }),
-      { a: 1, b: 2, c: 3 },
-      'New properties are added'
-    );
-
-    assert.deepEqual(
-      mergeObject({ a: 1, b: 2, c: 3 }, { c: 4 }),
-      { a: 1, b: 2, c: 4 },
-      'Old properties are overwritten'
-    );
-
-    assert.deepEqual(
-      mergeObject({ a: 1, b: 2, c: 3 }, { a: 7, c: 23, d: { a: 1, b: 2, c: 3 } }),
-      { a: 7, b: 2, c: 23, d: { a: 1, b: 2, c: 3 } },
-      'Objects are merged recursively'
-    );
-
-    try {
-      mergeObject([], {});
-    } catch {
-      assert.ok(true, 'Array inputs throws error');
-    }
-  });
-});