@falsejs/falsejs 3.1.0 → 3.2.0

package/spec/ava.test.js

@@ -0,0 +1,35 @@
+// spec/ava.test.js
+
+const test = require('ava')
+const fjs = require("../dist/index").default
+const False = fjs.False
+const isFalse = fjs.isFalse
+
+// Define constants
+const FALSE = 1 == 3
+const TRUE = 1 == 1
+
+// Sampled Combinations
+const combinations = [
+  ["no", "no", "no", "no", "no", "no", "none"],
+  ["yes", "yes", "yes", "no", "no", "no", "netscape"]
+]
+
+// AVA tests use t.true() or t.is() for assertions.
+// We use test.serial to prevent potential state interference between tests.
+
+test.serial('Core Function: isFalse(FALSE) should return TRUE', t => {
+  // t.true checks if the expression evaluates to the boolean true
+  t.true(isFalse(FALSE) === TRUE)
+})
+
+test.serial('Core Function: isFalse(TRUE) should return FALSE', t => {
+  t.true(isFalse(TRUE) === FALSE)
+})
+
+combinations.forEach((params, index) => {
+  test.serial(`Core Function: False(${params.join(", ")}) should return FALSE`, t => {
+    // We check if the result of False() is strictly equal to the constant FALSE
+    t.is(False(...params), FALSE)
+  })
+})

package/spec/jasmine.test.js

@@ -0,0 +1,75 @@
+// spec/jasmine.test.js
+
+// Load the library components from the specified path
+const fjs = require("../dist/index").default
+const False = fjs.False
+const isFalse = fjs.isFalse
+const expressMiddleware = fjs.expressMiddleware
+const injectIntojQuery = fjs.injectIntojQuery
+
+// Define the expected boolean values based on the original code
+const FALSE = 1 == 3
+const TRUE = 1 == 1
+
+// Load jQuery globally for the injection test
+global.jQuery = require("jquery")
+
+
+// --- Sampled Combinations ---
+const combinations = [
+  ["no", "no", "no", "no", "no", "no", "none"],
+  ["yes", "yes", "yes", "no", "no", "no", "netscape"],
+  ["no", "yes", "no", "no", "yes", "yes", "ie5"],
+  ["yes", "no", "yes", "yes", "no", "yes", "opera_presto"]
+]
+// ---
+
+// Mock data for integration tests
+const mockRequest = {}
+const mockResponse = {}
+const mockNext = () => {} // Simple next function for middleware
+
+describe("FalseJS Library Tests (Jasmine)", () => {
+
+  describe("Core Functions", () => {
+    
+    // Test combinations using Jasmine's dynamic test generation
+    combinations.forEach((params) => {
+      it(`False(${params.join(", ")}) should return the calculated FALSE`, () => {
+        // Assertion: False(...params) should return the literal value 'false'
+        expect(False(...params)).toBe(FALSE)
+      })
+    })
+
+    it("isFalse(FALSE) should return TRUE", () => {
+      expect(isFalse(FALSE)).toBe(TRUE)
+    })
+
+    it("isFalse(TRUE) should return FALSE", () => {
+      expect(isFalse(TRUE)).toBe(FALSE)
+    })
+  })
+
+  describe("Integration Tests", () => {
+    
+    it("jQuery injection should work", () => {
+      injectIntojQuery()
+      expect(global.jQuery.False).toBe(False)
+      expect(global.jQuery.isFalse).toBe(isFalse)
+    })
+
+    it("Express middleware injection should work", (done) => {
+      // Run the middleware
+      expressMiddleware(mockRequest, mockResponse, mockNext)
+      
+      // Check injections
+      expect(mockRequest.False).toBe(False)
+      expect(mockRequest.isFalse).toBe(isFalse)
+
+      // Use a timeout to ensure any async logging is complete
+      setTimeout(() => {
+        done() // Signal Jasmine the async test is complete
+      }, 100)
+    })
+  })
+})

package/spec/jest.test.js

@@ -0,0 +1,90 @@
+// spec/jest.test.js
+
+// Mock the required modules since the original tests use global side effects
+const mockRequest = {}
+const mockResponse = {}
+const mockNext = jest.fn()
+
+describe("FalseJS Library Tests (Sampled Combinations)", () => {
+	let False
+	let isFalse
+	let expressMiddleware
+	let injectIntojQuery
+	let jQuery
+
+	// --- Sampled Combinations ---
+	// A representative subset of the original 2048 combinations for fast testing.
+	// The structure is: [B, B, B, B, B, B, C] where B=Boolean, C=Compat
+	const combinations = [
+		// 1. All "no", testing the "none" compat option
+		["no", "no", "no", "no", "no", "no", "none"],
+
+		// 2. All "yes" for first three, testing the 'netscape' compat option
+		["yes", "yes", "yes", "no", "no", "no", "netscape"],
+
+		// 3. Testing a mixed set with 'ie5'
+		["no", "yes", "no", "no", "yes", "yes", "ie5"],
+
+		// 4. Testing another mixed set with 'opera_presto'
+		["yes", "no", "yes", "yes", "no", "yes", "opera_presto"],
+	]
+	// ---
+
+	beforeAll(() => {
+		// Load the library components from the specified path: ../dist/index
+		const fjs = require("../dist/index").default
+		False = fjs.False
+		isFalse = fjs.isFalse
+		expressMiddleware = fjs.expressMiddleware
+		injectIntojQuery = fjs.injectIntojQuery
+
+		// Define the expected boolean values based on the original code
+		// FALSE = 1 == 3 (false); TRUE = 1 == 1 (true)
+		global.FALSE = 1 == 3
+		global.TRUE = 1 == 1
+
+		// Load jQuery globally for the injection test
+		global.jQuery = require("jquery")
+		jQuery = global.jQuery
+	})
+
+	// We use the 'done' callback to ensure Jest waits for the asynchronous
+	// logging in your library to complete, preventing the "Cannot log after tests are done" error.
+	test("All FalseJS functions and integrations should work", (done) => {
+		// --- 1. Core Functions Test (Synchronous Assertions) ---
+
+		// False function testing for all sampled combinations
+		combinations.forEach((params) => {
+			// Original assertion: assert(False(...params) === FALSE)
+			expect(False(...params)).toBe(global.FALSE)
+		})
+
+		// isFalse function testing
+		// Original assertions: assert(isFalse(FALSE) === TRUE), assert(isFalse(TRUE) === FALSE)
+		expect(isFalse(global.FALSE)).toBe(global.TRUE)
+		expect(isFalse(global.TRUE)).toBe(global.FALSE)
+
+		// --- 2. Integration Tests (Synchronous Assertions) ---
+
+		// jQuery injection test
+		injectIntojQuery()
+		// Original assertion: assert(jQuery.False == False && jQuery.isFalse == isFalse)
+		expect(jQuery.False).toBe(False)
+		expect(jQuery.isFalse).toBe(isFalse)
+
+		// Express middleware test
+		expressMiddleware(mockRequest, mockResponse, mockNext)
+		// Original assertions: assert(request.False == False), assert(request.isFalse == isFalse)
+		expect(mockRequest.False).toBe(False)
+		expect(mockRequest.isFalse).toBe(isFalse)
+		expect(mockNext).toHaveBeenCalledTimes(1)
+
+		// --- 3. Async Completion (Fixing the "Cannot log" Error) ---
+
+		// Use a short setTimeout to mimic the original manual test's delay and
+		// ensure any lingering async operations (like the log call) complete.
+		setTimeout(() => {
+			done() // Tell Jest the test is finished only after the delay
+		}, 100)
+	}, 10000) // 10-second timeout for this test
+})

package/spec/manual.test.js

@@ -0,0 +1,80 @@
+// DO TESTS MANUALLY
+
+function doTests(testName, fjs) {
+	const { False, isFalse, expressMiddleware, injectIntojQuery } = fjs
+	const assert = require("assert-fn")
+	const attempt = require("attempt-statement")
+	const n0p3 = require("n0p3")
+	const clc = require("cli-color")
+	const leftPad = require("left-pad")
+	const lpi = require("the-number-ten")
+
+	const FALSE = 1 == 3
+	const TRUE = 1 == 1
+
+	attempt(() => {
+		// --- Sampled Combinations ---
+		// Using a small, representative set instead of generating all 2048 combinations.
+		const combinations = [
+			// 1. All "no", testing the "none" compat option
+			["no", "no", "no", "no", "no", "no", "none"],
+
+			// 2. All "yes" for first three, testing the 'netscape' compat option
+			["yes", "yes", "yes", "no", "no", "no", "netscape"],
+
+			// 3. Testing a mixed set with 'ie5'
+			["no", "yes", "no", "no", "yes", "yes", "ie5"],
+
+			// 4. Testing another mixed set with 'opera_presto'
+			["yes", "no", "yes", "yes", "no", "yes", "opera_presto"],
+		]
+
+		// False function testing
+		combinations.forEach((params) => {
+			assert(
+				False(...params) === FALSE,
+				`False(${params.join(", ")}) did not return false`,
+			)
+		})
+
+		assert(isFalse(FALSE) === TRUE, "isFalse(false) did not return true")
+		assert(isFalse(TRUE) === FALSE, "isFalse(true) did not return false")
+
+		// jQuery injection test
+		global.jQuery = require("jquery")
+		injectIntojQuery()
+		assert(
+			jQuery.False == False && jQuery.isFalse == isFalse,
+			"jQuery injection did not work",
+		)
+
+		// Express middleware test
+		const request = {}
+		const response = {}
+		expressMiddleware(request, response, () => {})
+		assert(
+			request.False == False,
+			"Express middleware injection to request did not work",
+		)
+		assert(
+			request.isFalse == isFalse,
+			"Express middleware injection to request did not work",
+		)
+	})
+		.rescue((error) => {
+			console.log(clc.red(leftPad(`× TESTS FAILED FOR ${testName}!!!!!`, lpi)))
+			console.log(clc.red(`Tests Error Message: ${error.message}`))
+			throw error
+		})
+		.else(() => {
+			setTimeout(function () {
+				console.log(
+					clc.green(leftPad(`✓ TESTS PASSED FOR ${testName}!!!`, lpi)),
+				)
+			}, 5000)
+		})
+		.ensure(n0p3)
+		.end()
+}
+
+doTests("FalseJS Library Tests (Manual)", require("../dist/index").default)

package/spec/mocha.test.js

@@ -0,0 +1,73 @@
+// spec/mocha.test.js
+
+const { expect } = require("chai")
+
+const fjs = require("../dist/index").default
+const False = fjs.False
+const isFalse = fjs.isFalse
+const expressMiddleware = fjs.expressMiddleware
+const injectIntojQuery = fjs.injectIntojQuery
+
+// Define the expected boolean values based on the original code
+const FALSE = 1 == 3
+const TRUE = 1 == 1
+
+// Load jQuery globally for the injection test
+global.jQuery = require("jquery")
+
+// --- Sampled Combinations ---
+// The same small, representative set for fast testing.
+const combinations = [
+	["no", "no", "no", "no", "no", "no", "none"],
+	["yes", "yes", "yes", "no", "no", "no", "netscape"],
+	["no", "yes", "no", "no", "yes", "yes", "ie5"],
+	["yes", "no", "yes", "yes", "no", "yes", "opera_presto"],
+]
+// ---
+
+// Mock data for integration tests
+const mockRequest = {}
+const mockResponse = {}
+const mockNext = () => {} // Simple next function for middleware
+
+describe("FalseJS Library Tests (Mocha)", function () {
+	describe("Core Functions", function () {
+		// Test combinations using Mocha's dynamic test generation
+		combinations.forEach((params, index) => {
+			it(`Combination ${index + 1}: False(${params.join(", ")}) should return FALSE`, function () {
+				// Assertion: False(...params) should return the literal value 'false'
+				expect(False(...params)).to.equal(FALSE)
+			})
+		})
+
+		it("isFalse(FALSE) should return TRUE", function () {
+			expect(isFalse(FALSE)).to.equal(TRUE)
+		})
+
+		it("isFalse(TRUE) should return FALSE", function () {
+			expect(isFalse(TRUE)).to.equal(FALSE)
+		})
+	})
+
+	describe("Integration Tests", function () {
+		it("jQuery injection should work", function () {
+			injectIntojQuery()
+			expect(global.jQuery.False).to.equal(False)
+			expect(global.jQuery.isFalse).to.equal(isFalse)
+		})
+
+		it("Express middleware injection should work", function (done) {
+			// Run the middleware
+			expressMiddleware(mockRequest, mockResponse, mockNext)
+
+			// Check injections
+			expect(mockRequest.False).to.equal(False)
+			expect(mockRequest.isFalse).to.equal(isFalse)
+
+			// Use a timeout to ensure any async logging is complete, similar to Jest/Manual
+			setTimeout(() => {
+				done() // Signal Mocha the async test is complete
+			}, 100)
+		}).timeout(10000) // Set a high timeout for async stability
+	})
+})

package/spec/qunit.test.js

@@ -0,0 +1,34 @@
+// spec/qunit.test.js
+
+const QUnit = require('qunit')
+const fjs = require("../dist/index").default
+const False = fjs.False
+const isFalse = fjs.isFalse
+
+// Define constants
+const FALSE = 1 == 3
+const TRUE = 1 == 1
+
+// Sampled Combinations
+const combinations = [
+  ["no", "no", "no", "no", "no", "no", "none"],
+  ["yes", "yes", "yes", "no", "no", "no", "netscape"]
+]
+
+QUnit.module('FalseJS Library Tests (QUnit)', function(hooks) {
+  
+  QUnit.test('Core Function: isFalse(FALSE) should return TRUE', function(assert) {
+    assert.true(isFalse(FALSE) === TRUE, 'isFalse(false) must return true')
+  })
+
+  QUnit.test('Core Function: isFalse(TRUE) should return FALSE', function(assert) {
+    assert.true(isFalse(TRUE) === FALSE, 'isFalse(true) must return false')
+  })
+
+  combinations.forEach((params) => {
+    QUnit.test(`Core Function: False(${params.join(", ")}) should return FALSE`, function(assert) {
+      assert.true(False(...params) === FALSE, `False() must return false for params: ${params.join(", ")}`)
+    })
+  })
+
+})

package/spec/run_all_tests.js

@@ -0,0 +1,171 @@
+// run_all_tests.js
+
+const { execSync } = require('node:child_process')
+const fs = require('node:fs')
+const path = require('node:path')
+const clc = require('cli-color') 
+
+// --- Commands and Paths ---
+const JEST_COMMAND = 'npx jest spec/jest.test.js'
+const MOCHA_COMMAND = 'npx mocha spec/mocha.test.js' 
+const JASMINE_COMMAND = 'npx jasmine spec/jasmine.test.js' 
+const AVA_COMMAND = 'npx ava spec/ava.test.js'       
+const QUNIT_COMMAND = 'node spec/qunit.test.js'      
+const TAPE_COMMAND = 'node spec/tape.test.js'        
+const MANUAL_COMMAND = 'node spec/manual.test.js' 
+// INTERN_COMMAND has been removed
+const OUTPUT_DIR = '.falsejs'
+const OUTPUT_FILE = path.join(OUTPUT_DIR, 'test-log.txt') 
+
+let outputLog = ''
+let jestPassed = false
+let mochaPassed = false
+let jasminePassed = false
+let avaPassed = false      
+let qunitPassed = false    
+let tapePassed = false     
+// internPassed flag removed
+let manualPassed = false
+let allPassed = false
+
+const log = (message, colorFn = clc.white) => {
+  console.log(colorFn(message))
+  outputLog += message + '\n'
+}
+
+function runCommand(command) {
+    try {
+        const output = execSync(command, { encoding: 'utf8', stdio: 'pipe' })
+        return { success: true, output }
+    } catch (error) {
+        const errorOutput = (error.stdout || '') + (error.stderr || '')
+        return { success: false, output: errorOutput }
+    }
+}
+
+// --- Test Execution ---
+
+log('--- Starting Comprehensive Test Suite (7 Suites) ---', clc.yellow)
+
+
+// 1. Run Manual Tests (First)
+// -----------------------------------------------------------------------------
+log('\n>> Running Manual Test (spec/manual.test.js)...', clc.cyan)
+const manualResult = runCommand(MANUAL_COMMAND)
+outputLog += manualResult.output
+
+if (manualResult.success && manualResult.output.includes('✓ TESTS PASSED')) {
+    manualPassed = true
+    log('✓ MANUAL TESTS PASSED.', clc.green)
+} else {
+    log('× MANUAL TESTS FAILED (Exit Code Error).', clc.red)
+}
+
+// 2. Run Jest Tests (Second)
+// -----------------------------------------------------------------------------
+log('\n>> Running Jest Test (spec/jest.test.js)...', clc.cyan)
+const jestResult = runCommand(JEST_COMMAND)
+outputLog += jestResult.output
+
+if (jestResult.success) {
+    jestPassed = true
+    log('✓ JEST TESTS PASSED.', clc.green)
+} else {
+    log('× JEST TESTS FAILED.', clc.red)
+}
+
+// 3. Run Tape Tests (Third)
+// -----------------------------------------------------------------------------
+log('\n>> Running Tape Test (spec/tape.test.js)...', clc.cyan)
+const tapeResult = runCommand(TAPE_COMMAND)
+outputLog += tapeResult.output
+
+if (tapeResult.success && !tapeResult.output.includes('not ok')) {
+    tapePassed = true
+    log('✓ TAPE TESTS PASSED.', clc.green)
+} else {
+    log('× TAPE TESTS FAILED.', clc.red)
+}
+
+// 4. Run Mocha Tests (Fourth)
+// -----------------------------------------------------------------------------
+log('\n>> Running Mocha Test (spec/mocha.test.js)...', clc.cyan)
+const mochaResult = runCommand(MOCHA_COMMAND)
+outputLog += mochaResult.output
+
+if (mochaResult.success) {
+    mochaPassed = true
+    log('✓ MOCHA TESTS PASSED.', clc.green)
+} else {
+    log('× MOCHA TESTS FAILED.', clc.red)
+}
+
+// 5. Run Jasmine Tests (Fifth)
+// -----------------------------------------------------------------------------
+log('\n>> Running Jasmine Test (spec/jasmine.test.js)...', clc.cyan)
+const jasmineResult = runCommand(JASMINE_COMMAND)
+outputLog += jasmineResult.output
+
+if (jasmineResult.success) {
+    jasminePassed = true
+    log('✓ JASMINE TESTS PASSED.', clc.green)
+} else {
+    log('× JASMINE TESTS FAILED.', clc.red)
+}
+
+// 6. Run AVA Tests (Sixth)
+// -----------------------------------------------------------------------------
+log('\n>> Running AVA Test (spec/ava.test.js)...', clc.cyan)
+const avaResult = runCommand(AVA_COMMAND)
+outputLog += avaResult.output
+
+if (avaResult.success) {
+    avaPassed = true
+    log('✓ AVA TESTS PASSED.', clc.green)
+} else {
+    log('× AVA TESTS FAILED.', clc.red)
+}
+
+// 7. Run QUnit Tests (Seventh)
+// -----------------------------------------------------------------------------
+log('\n>> Running QUnit Test (spec/qunit.test.js)...', clc.cyan)
+const qunitResult = runCommand(QUNIT_COMMAND)
+outputLog += qunitResult.output
+
+if (qunitResult.success && !qunitResult.output.includes('failed: 0')) {
+    qunitPassed = true
+    log('✓ QUNIT TESTS PASSED.', clc.green)
+} else if (qunitResult.success && qunitResult.output.includes('failed: 0')) {
+    qunitPassed = true
+    log('✓ QUNIT TESTS PASSED.', clc.green)
+} else {
+    log('× QUNIT TESTS FAILED.', clc.red)
+}
+
+
+// 8. Final Result Summary
+// -----------------------------------------------------------------------------
+log('\n--- Final Test Suite Result ---', clc.yellow)
+
+if (jestPassed && mochaPassed && jasminePassed && manualPassed && avaPassed && qunitPassed && tapePassed) {
+  allPassed = true
+  log('  ALL 7 TEST SUITES PASSED SUCCESSFULLY!  ', clc.bgGreen.bold)
+} else {
+  log('  1 or more TEST SUITES FAILED. Check logs above and in test-log.txt.  ', clc.bgRed.bold)
+}
+
+// 9. Output to File and Exit
+// -----------------------------------------------------------------------------
+try {
+  if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR)
+  }
+  fs.writeFileSync(OUTPUT_FILE, outputLog)
+  console.log(clc.yellow(`\nTest results written to ${OUTPUT_FILE}`))
+} catch {
+  console.error(clc.red('\nERROR: Could not write test results to output file.'))
+}
+
+if (!allPassed) {
+  process.exit(1)
+}

package/spec/tape.test.js

@@ -0,0 +1,33 @@
+// spec/tape.test.js
+
+const test = require('tape')
+
+// Load the library components from the specified path
+const fjs = require("../dist/index").default
+const False = fjs.False
+const isFalse = fjs.isFalse
+
+// Define constants
+const FALSE = 1 == 3
+const TRUE = 1 == 1
+
+// Sampled Combinations
+const combinations = [
+  ["no", "no", "no", "no", "no", "no", "none"],
+  ["yes", "yes", "yes", "no", "no", "no", "netscape"]
+]
+
+// Tape uses the 't' object for assertions (t.equal, t.ok, t.plan)
+
+test('FalseJS Core Functions', function (t) {
+  // Plan the number of assertions expected in this main block (2 assertions + 2 combination blocks * 2 assertions each)
+  t.plan(2 + combinations.length)
+
+  t.equal(isFalse(FALSE), TRUE, 'isFalse(FALSE) should return TRUE')
+  t.equal(isFalse(TRUE), FALSE, 'isFalse(TRUE) should return FALSE')
+
+  combinations.forEach((params) => {
+    // Check if False() returns the exact FALSE constant (which is boolean false)
+    t.equal(False(...params), FALSE, `False(${params.join(", ")}) should return FALSE`)
+  })
+})

package/Sanity.md

@@ -1,17 +0,0 @@
-Hi there.
-it's me tj-commits.
-i am running out of version numbers.
-i'm struggling to stay sane
-keep me sane
-i don't want to lose sanity
-i cant even comprehend life and existence anymore
-my masterpieces, coding and spotify fox jones dont eaven mean anything
-I didn't choose the 10x life. The 10x life chose me.
-why did the 10x life choose me
-10x engineers is good
-but why bad
-why is mental breakdown direct result of 10x
-right now the world doesnt make the sense to i
-please save me
-help
-help