Vandium Utils

Common errors

• TypeError: (0 , vandium_utils_1.templateString) is not a function

  cause This error typically occurs when using CommonJS `require` syntax (e.g., `const { templateString } = require('vandium-utils');`) in an environment configured for ES Modules, or when attempting to import a non-existent or incorrectly named export.
  fix Ensure your module context matches your import statement. For ESM, use `import { templateString } from 'vandium-utils';`. If in CJS, verify the export name and ensure the path is correct.

• ReferenceError: require is not defined

  cause Attempting to use the CommonJS `require()` function within an ECMAScript Module (ESM) file, where `import` statements are expected.
  fix Convert `require` statements to `import` statements: `const { funcName } = require('pkg');` becomes `import { funcName } from 'pkg';`. Ensure your `package.json` has `"type": "module"` if you intend to use ESM, or use a `.mjs` file extension.

Warnings

• breaking While specific breaking changes from v1 to v2 are not extensively documented in the README excerpt, major version bumps often introduce API changes. Developers should consult the full change log or release notes when migrating from `vandium-utils@1.x` to `2.x` to identify potential breaking changes in function signatures or behavior.
  Fix: Review the official changelog or GitHub releases for `vandium-utils` for detailed migration guides between major versions.
• gotcha The `clone` function performs a deep clone for objects and arrays. However, if the input `value` is not an object or `null`, the function simply returns the existing value without modification. This can be surprising if expecting a new instance for all data types.
  Fix: Be aware of `clone`'s behavior for non-object/non-array inputs. If a new instance is required for primitives, explicitly reassign them (e.g., `const newVar = oldVar;`).
• gotcha The `parseBoolean` function has specific string values it recognizes as `true` or `false` (case-insensitive: "on", "yes", "true", "off", "no", "false"). Any other string or non-boolean value that doesn't match these specific strings will resolve to `false` (after internal string conversions like `String(value).toLowerCase()`), which might not be the expected boolean logic for all arbitrary inputs.
  Fix: Ensure inputs to `parseBoolean` are among the explicitly supported string values or actual boolean literals. For other values, perform explicit type conversions or checks before passing to `parseBoolean` if specific boolean outcomes are critical.

Install

• npm install vandium-utils npm
• yarn add vandium-utils yarn
• pnpm add vandium-utils pnpm

Imports

• templateString
  wrong:

  const templateString = require('vandium-utils').templateString;

  correct:

  import { templateString } from 'vandium-utils';

  The recommended way for named imports in both ESM and CJS contexts.
• isArray
  wrong:

  import isArray from 'vandium-utils';

  correct:

  import { isArray } from 'vandium-utils';

  All utility functions are named exports; there is no default export.
• clone
  wrong:

  import * as VandiumUtils from 'vandium-utils';

  correct:

  const { clone } = require('vandium-utils');

  While `import * as` works, directly importing the needed function is more tree-shakeable and idiomatic.

Quickstart

Demonstrates `templateString` for string interpolation, `isObjectEmpty` for object validation, and `clone` for deep object copying.

import { templateString, isObjectEmpty, clone } from 'vandium-utils';

// Example 1: Basic string templating
const user = { name: 'Alice', city: 'Wonderland' };
const greeting = templateString('Hello ${name} from ${city}!', user);
console.log(greeting); // Expected: "Hello Alice from Wonderland!"

// Example 2: Checking for empty objects
const emptyObj = {};
const filledObj = { id: 1 };
console.log(`Is emptyObj empty? ${isObjectEmpty(emptyObj)}`); // Expected: "Is emptyObj empty? true"
console.log(`Is filledObj empty? ${isObjectEmpty(filledObj)}`); // Expected: "Is filledObj empty? false"

// Example 3: Cloning an object
const originalObject = { a: 1, b: { c: 2 } };
const clonedObject = clone(originalObject);
clonedObject.b.c = 99;
console.log('Original object after clone modification:', originalObject); // Expected: { a: 1, b: { c: 2 } }
console.log('Cloned object:', clonedObject); // Expected: { a: 1, b: { c: 99 } }