is-object-empty2 1.0.0

package/.github/workflows/npmpublish.yml

@@ -0,0 +1,48 @@
+# This workflow will run tests using node and then publish a package to npm using Trusted Publishing (OIDC)
+# For more information see: https://docs.npmjs.com/using-private-packages-in-a-ci-cd-workflow
+
+name: is-object-empty2 NPM Package
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    # Skip Dependabot PRs for CI/CD
+    if: ${{ github.actor != 'dependabot[bot]' }}
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+
+      - run: npm install
+      - run: npm test
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+
+    # Skip Dependabot PRs
+    if: ${{ github.actor != 'dependabot[bot]' }}
+
+    # Required for OIDC Trusted Publishing
+    permissions:
+      contents: read
+      id-token: write # 👈 REQUIRED for Trusted Publishing
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+          registry-url: https://registry.npmjs.org/
+
+      - run: npm install
+      - run: npm publish

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alex
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# is-object-empty2
+
+<p align="center"><a href="https://nodei.co/npm/is-object-empty2/"><img src="https://nodei.co/npm/is-object-empty2.png"></a></a></p>
+<p align="center">
+  <img src="https://img.shields.io/badge/License-MIT-yellow.svg">
+</p>
+
+# Simple yet robust NPM package that checks if a value is a plain empty object in `JavaScript` and `TypeScript`.
+
+- Returns `true` **only** for plain objects with no own enumerable properties (`{}` or `Object.create(null)`).
+- Returns `false` for arrays, `null`, `undefined`, functions, symbols, BigInt, or objects with keys.
+- Correctly handles:
+  - Objects created with `Object.create(null)`
+  - Frozen or sealed objects
+  - Proxy objects (both empty and with keys)
+  - Objects with inherited properties
+  - Objects with non-enumerable properties
+  - Nested or deeply nested objects
+
+
+# 📦 Install via [NPM](https://www.npmjs.com/package/is-object-empty2)
+
+```bash
+$ npm i is-object-empty2
+```
+
+# 💻 Usage
+
+- Returns `true` only for empty objects (`{}`), and `false` for arrays, null, undefined, or objects with keys.
+- See examples below
+
+# JavaScript
+```javascript
+const isObjectEmpty2 = require('is-object-empty');
+
+console.log(isObjectEmpty2({}));           // true
+console.log(isObjectEmpty2({ a: 1 }));     // false
+console.log(isObjectEmpty2([]));           // false
+console.log(isObjectEmpty2(null));         // false
+console.log(isObjectEmpty2(undefined));    // false
+```
+
+# TypeScript
+```javascript
+import isObjectEmpty2 = require('is-object-empty');
+
+const testValues: unknown[] = [
+    {},
+    { a: 1 },
+    [],
+    null,
+    undefined,
+    Object.create(null),
+    { nested: {} }
+];
+
+for (const value of testValues) {
+    const result: boolean = isObjectEmpty2(value);
+    console.log(`${JSON.stringify(value)} → ${result}`);
+}
+
+/*
+--| Expected values:
+
+{} → true
+{"a":1} → false
+[] → false
+null → false
+undefined → false
+{} → true
+{"nested":{}} → false
+*/
+```

package/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Checks if a given value is a plain object and has no own properties.
+ * Returns `true` only for empty plain objects (`{}`), and `false` for arrays, null, undefined, or objects with keys.
+ *
+ * @param {unknown} obj - The value to check.
+ * @returns {boolean} - `true` if the value is an empty object, otherwise `false`.
+ *
+ * @example
+ * isObjectEmpty2({});           // true
+ * isObjectEmpty2({ a: 1 });     // false
+ * isObjectEmpty2([]);           // false
+ * isObjectEmpty2(null);         // false
+ * isObjectEmpty2(undefined);    // false
+ */
+declare const isObjectEmpty2: (obj: unknown) => boolean;
+
+export = isObjectEmpty2;

package/index.js

@@ -0,0 +1,25 @@
+/**
+ *  is-object-empty2 - 📦 Tiny utility to check if a value is a plain empty object in JavaScript and TypeScript
+ *  @version: v1.0.0
+ *  @link: https://github.com/tutyamxx/is-object-empty2
+ *  @license: MIT
+ **/
+
+
+/**
+ * Checks if a given value is a plain object with no own properties.
+ * Returns `true` only for empty objects (`{}`), and `false` for arrays, null, undefined, or objects with keys.
+ *
+ * @param {unknown} obj - The value to check.
+ * @returns {boolean} `true` if the value is an empty plain object, otherwise `false`.
+ *
+ * @example
+ * isObjectEmpty2({});           // true
+ * isObjectEmpty2({ a: 1 });     // false
+ * isObjectEmpty2([]);           // false
+ * isObjectEmpty2(null);         // false
+ * isObjectEmpty2(undefined);    // false
+ */
+const isObjectEmpty2 = (obj) => obj !== null && typeof obj === 'object' && !Array.isArray(obj) ? Object.keys(obj).length === 0 : false;
+
+module.exports = isObjectEmpty2;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "is-object-empty2",
+  "version": "1.0.0",
+  "description": "📦 Tiny utility to check if a value is a plain empty object in JavaScript or TypeScript",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "jest --verbose"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tutyamxx/is-object-empty"
+  },
+  "keywords": [
+    "is-object-empty",
+    "isemptyobject",
+    "is-object-empty",
+    "empty-object"
+  ],
+  "author": "tuty",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/tutyamxx/is-object-empty/issues"
+  },
+  "homepage": "https://github.com/tutyamxx/is-object-empty#readme",
+  "devDependencies": {
+    "jest": "^30.2.0"
+  },
+  "jest": {
+    "testEnvironment": "node"
+  }
+}

package/test/index.test.js

@@ -0,0 +1,87 @@
+const isObjectEmpty2 = require('../index.js')
+
+describe('isObjectEmpty2', () => {
+    test('Returns true for an empty object', () => expect(isObjectEmpty2({})).toBe(true));
+
+    test('Returns false for a non-empty object', () => {
+        expect(isObjectEmpty2({ a: 1 })).toBe(false);
+        expect(isObjectEmpty2({ key: 'value' })).toBe(false);
+    });
+
+    test('Returns false for arrays', () => {
+        expect(isObjectEmpty2([])).toBe(false);
+        expect(isObjectEmpty2([1, 2, 3])).toBe(false);
+    });
+
+    test('Returns false for null and undefined', () => {
+        expect(isObjectEmpty2(null)).toBe(false);
+        expect(isObjectEmpty2(undefined)).toBe(false);
+    });
+
+    test('Returns false for non-object types', () => {
+        expect(isObjectEmpty2('string')).toBe(false);
+        expect(isObjectEmpty2(123)).toBe(false);
+        expect(isObjectEmpty2(true)).toBe(false);
+        expect(isObjectEmpty2(Infinity)).toBe(false);
+        expect(isObjectEmpty2(-Infinity)).toBe(false);
+        expect(isObjectEmpty2(() => {})).toBe(false);
+        expect(isObjectEmpty2(Symbol('sym'))).toBe(false);
+        expect(isObjectEmpty2(BigInt(123))).toBe(false);
+    });
+
+    test('Returns true for object created with Object.create(null)', () => {
+        const obj = Object.create(null);
+        expect(isObjectEmpty2(obj)).toBe(true);
+
+        obj.a = 1;
+
+        expect(isObjectEmpty2(obj)).toBe(false);
+    });
+
+    test('Nested empty object still counts as non-empty', () => expect(isObjectEmpty2({ nested: {} })).toBe(false));
+
+    test('Deeply nested empty objects still count as non-empty', () => {
+        const obj = { a: { b: { c: {} } } };
+        expect(isObjectEmpty2(obj)).toBe(false);
+    });
+
+    test('Objects with inherited properties are considered non-empty', () => {
+        function Parent() {
+            this.a = 1;
+        }
+
+        const child = new Parent();
+        expect(isObjectEmpty2(child)).toBe(false);
+    });
+
+    test('Frozen empty objects still return true', () => {
+        const obj = Object.freeze({});
+        expect(isObjectEmpty2(obj)).toBe(true);
+    });
+
+    test('Sealed empty objects still return true', () => {
+        const obj = Object.seal({});
+        expect(isObjectEmpty2(obj)).toBe(true);
+    });
+
+    test('Proxy objects with empty target return true', () => {
+        const target = {};
+        const proxy = new Proxy(target, {});
+
+        expect(isObjectEmpty2(proxy)).toBe(true);
+    });
+
+    test('Proxy objects with keys return false', () => {
+        const target = { a: 1 };
+        const proxy = new Proxy(target, {});
+
+        expect(isObjectEmpty2(proxy)).toBe(false);
+    });
+
+    test('Objects with non-enumerable properties are considered empty', () => {
+        const obj = {};
+
+        Object.defineProperty(obj, 'hidden', { value: 123, enumerable: false });
+        expect(isObjectEmpty2(obj)).toBe(true);
+    });
+});