inqjs 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 [Your Name]
+
+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,226 @@
+# inqjs (Integrated Query for JavaScript)
+
+A lightweight, dependency-free LINQ engine for TypeScript and JavaScript with comprehensive query capabilities.
+
+> **Note**: This project was developed with heavy assistance from AI (Google Gemini), demonstrating modern AI-powered software development workflows.
+
+## Features
+
+✨ **Comprehensive LINQ Operations**
+- Filtering: `where`, `distinct`
+- Projection: `select`
+- Ordering: `orderBy`
+- Partitioning: `skip`, `take`
+- Aggregation: `sum`, `min`, `max`, `count`
+- Quantifiers: `any`, `all`
+- Element: `first`
+- Set Operations: `union`, `intersect`, `except`
+- Sequence: `append`, `prepend`, `concat`
+
+🚀 **Lazy Evaluation**
+- Operators are lazily evaluated using generators
+- Only materializes when calling terminal operators like `toArray()`
+
+⚡ **Async Support**
+- Full async/await support with `AsyncQuery`
+- Works with `AsyncIterable<T>`
+
+📦 **JSON Querying**
+- Query JSON data directly with `fromJson`, `fromJsonArray`, `fromJsonObject`
+
+🔒 **Type Safe**
+- Written in TypeScript with `strict: true`
+- Full type inference and safety
+
+🎯 **Zero Dependencies**
+- No external runtime dependencies
+- Works with any `Iterable<T>` (Arrays, Sets, Maps, Generators)
+
+## Installation
+
+```bash
+npm install inqjs
+```
+
+## Quick Start
+
+### Basic Query (Sync)
+
+```typescript
+import { from } from 'inqjs';
+
+const numbers = [1, 2, 3, 4, 5, 6];
+
+const result = from(numbers)
+  .where(x => x % 2 === 0)
+  .select(x => x * x)
+  .orderBy()
+  .toArray();
+
+console.log(result); // [4, 16, 36]
+```
+
+### Async Query
+
+```typescript
+import { fromAsync } from 'inqjs';
+
+async function* asyncNumbers() {
+  yield 1; yield 2; yield 3;
+}
+
+const result = await fromAsync(asyncNumbers())
+  .where(async x => x > 1)
+  .select(async x => x * 2)
+  .toArray();
+
+console.log(result); // [4, 6]
+```
+
+### JSON Querying
+
+```typescript
+import { fromJsonArray } from 'inqjs';
+
+const json = '[{"name": "Alice", "age": 25}, {"name": "Bob", "age": 30}]';
+
+const adults = fromJsonArray(json)
+  .where(user => user.age >= 18)
+  .select(user => user.name)
+  .toArray();
+
+console.log(adults); // ['Alice', 'Bob']
+```
+
+### Set Operations
+
+```typescript
+import { from } from 'inqjs';
+
+const list1 = [1, 2, 3, 4];
+const list2 = [3, 4, 5, 6];
+
+// Union
+from(list1).union(list2).toArray();
+// => [1, 2, 3, 4, 5, 6]
+
+// Intersect
+from(list1).intersect(list2).toArray();
+// => [3, 4]
+
+// Except
+from(list1).except(list2).toArray();
+// => [1, 2]
+```
+
+## API Reference
+
+### Query Creation
+
+- `from(iterable)` - Create query from any iterable
+- `fromAsync(asyncIterable)` - Create async query
+- `fromJson(jsonString)` - Parse and query JSON
+- `fromJsonArray(jsonString)` - Parse JSON array
+- `fromJsonObject(jsonString)` - Parse JSON object
+
+### Filtering & Projection
+
+- `where(predicate)` - Filter elements
+- `select(selector)` - Transform elements
+- `distinct(keySelector?)` - Remove duplicates
+
+### Ordering & Partitioning
+
+- `orderBy(keySelector?, comparer?)` - Sort elements
+- `skip(count)` - Skip first N elements
+- `take(count)` - Take first N elements
+
+### Aggregation
+
+- `sum(selector?)` - Sum numeric values
+- `min(selector?)` - Find minimum
+- `max(selector?)` - Find maximum
+- `count(predicate?)` - Count elements
+
+### Quantifiers
+
+- `any(predicate?)` - Check if any match
+- `all(predicate)` - Check if all match
+
+### Element Access
+
+- `first(predicate?)` - Get first element
+
+### Set Operations
+
+- `union(other, keySelector?)` - Set union
+- `intersect(other, keySelector?)` - Set intersection
+- `except(other, keySelector?)` - Set difference
+
+### Sequence Operations
+
+- `append(element)` - Add element to end
+- `prepend(element)` - Add element to start
+- `concat(other)` - Concatenate sequences
+
+### Terminal Operations
+
+- `toArray()` - Materialize to array
+- `toAsync()` - Convert to async query
+
+## Testing
+
+```bash
+# Run TypeScript tests (Vitest)
+npm test
+
+# Run JavaScript tests
+node tests/query.test.js
+```
+
+**Test Coverage**: 93 tests across TypeScript and JavaScript
+- 70 TypeScript tests (Vitest)
+- 23 Pure JavaScript tests
+
+## Examples
+
+See the `examples/` directory for more usage examples:
+- `examples/usage.ts` - Basic LINQ operations
+- `examples/json-usage.ts` - JSON querying examples
+
+## Architecture
+
+- **Lazy Evaluation**: Uses generator functions for deferred execution
+- **Immutable**: Each operation returns a new `Query` instance
+- **Type Safe**: Full TypeScript support with strict mode
+- **Modular**: Operators are separate modules in `src/operators/`
+
+## Limitations
+
+- `orderBy` materializes the sequence (requires full iteration to sort)
+- No `join` or `groupBy` operators (by design)
+- Set operations (`union`, `intersect`, `except`) materialize the second sequence
+
+## Development
+
+This project was developed using AI-assisted coding with Google Gemini, showcasing:
+- Rapid prototyping and iteration
+- Comprehensive test coverage generation
+- Documentation and example creation
+- Code refactoring and optimization
+
+The AI helped with:
+- Initial architecture design
+- Operator implementations (sync and async)
+- Test suite creation and organization
+- JSON querying capabilities
+- Set operations implementation
+- Documentation and examples
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! This project demonstrates how AI can accelerate development while maintaining code quality through comprehensive testing.

package/dist/src/Query.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromJsonObject = exports.fromJsonArray = exports.fromJson = exports.Query = void 0;
+exports.from = from;
+const guards_1 = require("./utils/guards");
+const comparers_1 = require("./utils/comparers");
+const where_1 = require("./operators/where");
+const select_1 = require("./operators/select");
+const orderBy_1 = require("./operators/orderBy");
+const skip_1 = require("./operators/skip");
+const distinct_1 = require("./operators/distinct");
+const any_1 = require("./operators/any");
+const all_1 = require("./operators/all");
+const sum_1 = require("./operators/sum");
+const min_1 = require("./operators/min");
+const max_1 = require("./operators/max");
+const first_1 = require("./operators/first");
+const toArray_1 = require("./operators/toArray");
+const take_1 = require("./operators/take");
+const count_1 = require("./operators/count");
+const AsyncQuery_1 = require("./async/AsyncQuery");
+class Query {
+    constructor(source) {
+        (0, guards_1.assertIterable)(source, 'source');
+        this._source = source;
+    }
+    [Symbol.iterator]() {
+        return this._source[Symbol.iterator]();
+    }
+    static from(source) {
+        if (source instanceof Map) {
+            return new Query(source.entries());
+        }
+        return new Query(source);
+    }
+    where(predicate) {
+        (0, guards_1.assertFunction)(predicate, 'predicate');
+        return new Query((0, where_1.where)(this._source, predicate));
+    }
+    select(selector) {
+        (0, guards_1.assertFunction)(selector, 'selector');
+        return new Query((0, select_1.select)(this._source, selector));
+    }
+    orderBy(keySelector = comparers_1.identity, comparer = comparers_1.defaultComparer) {
+        if (keySelector !== undefined)
+            (0, guards_1.assertFunction)(keySelector, 'keySelector');
+        if (comparer !== undefined)
+            (0, guards_1.assertFunction)(comparer, 'comparer');
+        return new Query((0, orderBy_1.orderBy)(this._source, keySelector, comparer));
+    }
+    skip(count) {
+        (0, guards_1.assertInteger)(count, 'count');
+        (0, guards_1.assertNonNegative)(count, 'count');
+        return new Query((0, skip_1.skip)(this._source, count));
+    }
+    distinct(keySelector = comparers_1.identity) {
+        if (keySelector !== undefined)
+            (0, guards_1.assertFunction)(keySelector, 'keySelector');
+        return new Query((0, distinct_1.distinct)(this._source, keySelector));
+    }
+    any(predicate) {
+        if (predicate !== undefined)
+            (0, guards_1.assertFunction)(predicate, 'predicate');
+        return (0, any_1.any)(this._source, predicate);
+    }
+    all(predicate) {
+        (0, guards_1.assertFunction)(predicate, 'predicate');
+        return (0, all_1.all)(this._source, predicate);
+    }
+    sum(selector = comparers_1.identity) {
+        if (selector !== undefined)
+            (0, guards_1.assertFunction)(selector, 'selector');
+        return (0, sum_1.sum)(this._source, selector);
+    }
+    min(selector = comparers_1.identity) {
+        if (selector !== undefined)
+            (0, guards_1.assertFunction)(selector, 'selector');
+        return (0, min_1.min)(this._source, selector);
+    }
+    max(selector = comparers_1.identity) {
+        if (selector !== undefined)
+            (0, guards_1.assertFunction)(selector, 'selector');
+        return (0, max_1.max)(this._source, selector);
+    }
+    first(predicate) {
+        if (predicate !== undefined)
+            (0, guards_1.assertFunction)(predicate, 'predicate');
+        return (0, first_1.first)(this._source, predicate);
+    }
+    toArray() {
+        return (0, toArray_1.toArray)(this._source);
+    }
+    take(count) {
+        (0, guards_1.assertInteger)(count, 'count');
+        (0, guards_1.assertNonNegative)(count, 'count');
+        return new Query((0, take_1.take)(this._source, count));
+    }
+    count(predicate) {
+        if (predicate !== undefined)
+            (0, guards_1.assertFunction)(predicate, 'predicate');
+        return (0, count_1.count)(this._source, predicate);
+    }
+    toAsync() {
+        return AsyncQuery_1.AsyncQuery.from(this._source);
+    }
+}
+exports.Query = Query;
+function from(source) {
+    return Query.from(source);
+}
+// JSON helpers
+var fromJson_1 = require("./json/fromJson");
+Object.defineProperty(exports, "fromJson", { enumerable: true, get: function () { return fromJson_1.fromJson; } });
+Object.defineProperty(exports, "fromJsonArray", { enumerable: true, get: function () { return fromJson_1.fromJsonArray; } });
+Object.defineProperty(exports, "fromJsonObject", { enumerable: true, get: function () { return fromJson_1.fromJsonObject; } });

package/dist/src/async/AsyncQuery.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQuery = void 0;
+exports.fromAsync = fromAsync;
+const guards_1 = require("../utils/guards");
+const comparers_1 = require("../utils/comparers");
+const whereAsync_1 = require("./operators/whereAsync");
+const selectAsync_1 = require("./operators/selectAsync");
+const orderByAsync_1 = require("./operators/orderByAsync");
+const skipAsync_1 = require("./operators/skipAsync");
+const distinctAsync_1 = require("./operators/distinctAsync");
+const anyAsync_1 = require("./operators/anyAsync");
+const allAsync_1 = require("./operators/allAsync");
+const sumAsync_1 = require("./operators/sumAsync");
+const minAsync_1 = require("./operators/minAsync");
+const maxAsync_1 = require("./operators/maxAsync");
+const firstAsync_1 = require("./operators/firstAsync");
+const toArrayAsync_1 = require("./operators/toArrayAsync");
+const takeAsync_1 = require("./operators/takeAsync");
+const countAsync_1 = require("./operators/countAsync");
+class AsyncQuery {
+    constructor(source) {
+        this._source = source;
+    }
+    [Symbol.asyncIterator]() {
+        return this._source[Symbol.asyncIterator]();
+    }
+    static from(source) {
+        async function* wrap(src) {
+            for await (const item of src) {
+                yield item;
+            }
+        }
+        return new AsyncQuery(wrap(source));
+    }
+    where(predicate) {
+        (0, guards_1.assertFunction)(predicate, 'predicate');
+        return new AsyncQuery((0, whereAsync_1.whereAsync)(this._source, predicate));
+    }
+    select(selector) {
+        (0, guards_1.assertFunction)(selector, 'selector');
+        return new AsyncQuery((0, selectAsync_1.selectAsync)(this._source, selector));
+    }
+    orderBy(keySelector = comparers_1.identity, comparer = comparers_1.defaultComparer) {
+        if (keySelector !== undefined)
+            (0, guards_1.assertFunction)(keySelector, 'keySelector');
+        if (comparer !== undefined)
+            (0, guards_1.assertFunction)(comparer, 'comparer');
+        return new AsyncQuery((0, orderByAsync_1.orderByAsync)(this._source, keySelector, comparer));
+    }
+    skip(count) {
+        (0, guards_1.assertInteger)(count, 'count');
+        (0, guards_1.assertNonNegative)(count, 'count');
+        return new AsyncQuery((0, skipAsync_1.skipAsync)(this._source, count));
+    }
+    distinct(keySelector = comparers_1.identity) {
+        if (keySelector !== undefined)
+            (0, guards_1.assertFunction)(keySelector, 'keySelector');
+        return new AsyncQuery((0, distinctAsync_1.distinctAsync)(this._source, keySelector));
+    }
+    any(predicate) {
+        if (predicate !== undefined)
+            (0, guards_1.assertFunction)(predicate, 'predicate');
+        return (0, anyAsync_1.anyAsync)(this._source, predicate);
+    }
+    all(predicate) {
+        (0, guards_1.assertFunction)(predicate, 'predicate');
+        return (0, allAsync_1.allAsync)(this._source, predicate);
+    }
+    sum(selector = comparers_1.identity) {
+        if (selector !== undefined)
+            (0, guards_1.assertFunction)(selector, 'selector');
+        return (0, sumAsync_1.sumAsync)(this._source, selector);
+    }
+    min(selector = comparers_1.identity) {
+        if (selector !== undefined)
+            (0, guards_1.assertFunction)(selector, 'selector');
+        return (0, minAsync_1.minAsync)(this._source, selector);
+    }
+    max(selector = comparers_1.identity) {
+        if (selector !== undefined)
+            (0, guards_1.assertFunction)(selector, 'selector');
+        return (0, maxAsync_1.maxAsync)(this._source, selector);
+    }
+    first(predicate) {
+        if (predicate !== undefined)
+            (0, guards_1.assertFunction)(predicate, 'predicate');
+        return (0, firstAsync_1.firstAsync)(this._source, predicate);
+    }
+    toArray() {
+        return (0, toArrayAsync_1.toArrayAsync)(this._source);
+    }
+    take(count) {
+        (0, guards_1.assertInteger)(count, 'count');
+        (0, guards_1.assertNonNegative)(count, 'count');
+        return new AsyncQuery((0, takeAsync_1.takeAsync)(this._source, count));
+    }
+    count(predicate) {
+        if (predicate !== undefined)
+            (0, guards_1.assertFunction)(predicate, 'predicate');
+        return (0, countAsync_1.countAsync)(this._source, predicate);
+    }
+}
+exports.AsyncQuery = AsyncQuery;
+function fromAsync(source) {
+    return AsyncQuery.from(source);
+}

package/dist/src/async/operators/allAsync.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allAsync = allAsync;
+async function allAsync(source, predicate) {
+    for await (const item of source) {
+        if (!(await predicate(item))) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/src/async/operators/anyAsync.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anyAsync = anyAsync;
+async function anyAsync(source, predicate) {
+    if (predicate) {
+        for await (const item of source) {
+            if (await predicate(item)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // If no predicate, check if source has any elements
+    const iterator = source[Symbol.asyncIterator]();
+    const result = await iterator.next();
+    return !result.done;
+}

package/dist/src/async/operators/countAsync.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countAsync = countAsync;
+async function countAsync(source, predicate) {
+    let count = 0;
+    for await (const item of source) {
+        if (!predicate || await predicate(item)) {
+            count++;
+        }
+    }
+    return count;
+}

package/dist/src/async/operators/distinctAsync.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distinctAsync = distinctAsync;
+async function* distinctAsync(source, keySelector) {
+    const seen = new Set();
+    for await (const item of source) {
+        const key = await keySelector(item);
+        if (!seen.has(key)) {
+            seen.add(key);
+            yield item;
+        }
+    }
+}

package/dist/src/async/operators/firstAsync.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstAsync = firstAsync;
+async function firstAsync(source, predicate) {
+    if (predicate) {
+        for await (const item of source) {
+            if (await predicate(item)) {
+                return item;
+            }
+        }
+    }
+    else {
+        const iterator = source[Symbol.asyncIterator]();
+        const result = await iterator.next();
+        if (!result.done) {
+            return result.value;
+        }
+    }
+    throw new Error('Sequence contains no matching element.');
+}

package/dist/src/async/operators/maxAsync.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxAsync = maxAsync;
+async function maxAsync(source, selector) {
+    let maxValue;
+    for await (const item of source) {
+        const value = await selector(item);
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw new TypeError('maxAsync: value must be a finite number.');
+        }
+        if (maxValue === undefined || value > maxValue) {
+            maxValue = value;
+        }
+    }
+    return maxValue;
+}

package/dist/src/async/operators/minAsync.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minAsync = minAsync;
+async function minAsync(source, selector) {
+    let minValue;
+    for await (const item of source) {
+        const value = await selector(item);
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw new TypeError('minAsync: value must be a finite number.');
+        }
+        if (minValue === undefined || value < minValue) {
+            minValue = value;
+        }
+    }
+    return minValue;
+}

package/dist/src/async/operators/orderByAsync.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderByAsync = orderByAsync;
+async function* orderByAsync(source, keySelector, comparer) {
+    const buffer = [];
+    for await (const item of source) {
+        buffer.push(item);
+    }
+    // We need to resolve keys for all items to sort them
+    const itemsWithKeys = await Promise.all(buffer.map(async (item) => ({
+        item,
+        key: await keySelector(item),
+    })));
+    itemsWithKeys.sort((a, b) => comparer(a.key, b.key));
+    for (const { item } of itemsWithKeys) {
+        yield item;
+    }
+}

package/dist/src/async/operators/selectAsync.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectAsync = selectAsync;
+async function* selectAsync(source, selector) {
+    let index = 0;
+    for await (const item of source) {
+        yield await selector(item, index++);
+    }
+}

package/dist/src/async/operators/skipAsync.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skipAsync = skipAsync;
+async function* skipAsync(source, count) {
+    let skipped = 0;
+    for await (const item of source) {
+        if (skipped < count) {
+            skipped++;
+            continue;
+        }
+        yield item;
+    }
+}

package/dist/src/async/operators/sumAsync.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sumAsync = sumAsync;
+async function sumAsync(source, selector) {
+    let total = 0;
+    for await (const item of source) {
+        const value = await selector(item);
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw new TypeError('sumAsync: value must be a finite number.');
+        }
+        total += value;
+    }
+    return total;
+}

package/dist/src/async/operators/takeAsync.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeAsync = takeAsync;
+async function* takeAsync(source, count) {
+    let taken = 0;
+    for await (const item of source) {
+        if (taken >= count)
+            break;
+        yield item;
+        taken++;
+    }
+}

package/dist/src/async/operators/toArrayAsync.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toArrayAsync = toArrayAsync;
+async function toArrayAsync(source) {
+    const result = [];
+    for await (const item of source) {
+        result.push(item);
+    }
+    return result;
+}

package/dist/src/async/operators/whereAsync.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whereAsync = whereAsync;
+async function* whereAsync(source, predicate) {
+    let index = 0;
+    for await (const item of source) {
+        if (await predicate(item, index++)) {
+            yield item;
+        }
+    }
+}

package/dist/src/json/fromJson.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromJson = fromJson;
+exports.fromJsonArray = fromJsonArray;
+exports.fromJsonObject = fromJsonObject;
+const Query_1 = require("../Query");
+/**
+ * Parse a JSON string and return a Query over the result.
+ * - If the JSON is an array, returns a Query over the array elements.
+ * - If the JSON is an object, returns a Query over the object's entries as [key, value] tuples.
+ * - For primitive values, wraps them in a single-element array.
+ */
+function fromJson(jsonString) {
+    const parsed = JSON.parse(jsonString);
+    if (Array.isArray(parsed)) {
+        return Query_1.Query.from(parsed);
+    }
+    else if (parsed !== null && typeof parsed === 'object') {
+        return Query_1.Query.from(Object.entries(parsed));
+    }
+    else {
+        // Primitive value - wrap in array
+        return Query_1.Query.from([parsed]);
+    }
+}
+/**
+ * Parse a JSON string as an array and return a Query over its elements.
+ * Throws if the JSON is not an array.
+ */
+function fromJsonArray(jsonString) {
+    const parsed = JSON.parse(jsonString);
+    if (!Array.isArray(parsed)) {
+        throw new TypeError('JSON value is not an array');
+    }
+    return Query_1.Query.from(parsed);
+}
+/**
+ * Parse a JSON string as an object and return a Query over its entries.
+ * Each entry is a [key, value] tuple.
+ * Throws if the JSON is not an object.
+ */
+function fromJsonObject(jsonString) {
+    const parsed = JSON.parse(jsonString);
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new TypeError('JSON value is not an object');
+    }
+    return Query_1.Query.from(Object.entries(parsed));
+}

package/dist/src/operators/all.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.all = all;
+function all(source, predicate) {
+    for (const item of source) {
+        if (!predicate(item)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/src/operators/any.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.any = any;
+function any(source, predicate) {
+    if (predicate) {
+        for (const item of source) {
+            if (predicate(item)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // If no predicate, check if source has any elements
+    const iterator = source[Symbol.iterator]();
+    return !iterator.next().done;
+}

package/dist/src/operators/count.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.count = count;
+function count(source, predicate) {
+    let count = 0;
+    for (const item of source) {
+        if (!predicate || predicate(item)) {
+            count++;
+        }
+    }
+    return count;
+}

package/dist/src/operators/distinct.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distinct = distinct;
+function* distinct(source, keySelector) {
+    const seen = new Set();
+    for (const item of source) {
+        const key = keySelector(item);
+        if (!seen.has(key)) {
+            seen.add(key);
+            yield item;
+        }
+    }
+}

package/dist/src/operators/first.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.first = first;
+function first(source, predicate) {
+    if (predicate) {
+        for (const item of source) {
+            if (predicate(item)) {
+                return item;
+            }
+        }
+    }
+    else {
+        const iterator = source[Symbol.iterator]();
+        const result = iterator.next();
+        if (!result.done) {
+            return result.value;
+        }
+    }
+    throw new Error('Sequence contains no matching element.');
+}

package/dist/src/operators/max.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.max = max;
+function max(source, selector) {
+    let maxValue;
+    for (const item of source) {
+        const value = selector(item);
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw new TypeError('max: value must be a finite number.');
+        }
+        if (maxValue === undefined || value > maxValue) {
+            maxValue = value;
+        }
+    }
+    return maxValue;
+}

package/dist/src/operators/min.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.min = min;
+function min(source, selector) {
+    let minValue;
+    for (const item of source) {
+        const value = selector(item);
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw new TypeError('min: value must be a finite number.');
+        }
+        if (minValue === undefined || value < minValue) {
+            minValue = value;
+        }
+    }
+    return minValue;
+}

package/dist/src/operators/orderBy.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orderBy = orderBy;
+function* orderBy(source, keySelector, comparer) {
+    const buffer = Array.from(source);
+    buffer.sort((a, b) => {
+        const keyA = keySelector(a);
+        const keyB = keySelector(b);
+        return comparer(keyA, keyB);
+    });
+    for (const item of buffer) {
+        yield item;
+    }
+}

package/dist/src/operators/select.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.select = select;
+function* select(source, selector) {
+    let index = 0;
+    for (const item of source) {
+        yield selector(item, index++);
+    }
+}

package/dist/src/operators/skip.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skip = skip;
+function* skip(source, count) {
+    let skipped = 0;
+    for (const item of source) {
+        if (skipped < count) {
+            skipped++;
+            continue;
+        }
+        yield item;
+    }
+}

package/dist/src/operators/sum.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sum = sum;
+function sum(source, selector) {
+    let total = 0;
+    for (const item of source) {
+        const value = selector(item);
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            throw new TypeError('sum: value must be a finite number.');
+        }
+        total += value;
+    }
+    return total;
+}

package/dist/src/operators/take.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.take = take;
+function* take(source, count) {
+    let taken = 0;
+    for (const item of source) {
+        if (taken >= count)
+            break;
+        yield item;
+        taken++;
+    }
+}

package/dist/src/operators/toArray.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toArray = toArray;
+function toArray(source) {
+    return Array.from(source);
+}

package/dist/src/operators/where.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.where = where;
+function* where(source, predicate) {
+    let index = 0;
+    for (const item of source) {
+        if (predicate(item, index++)) {
+            yield item;
+        }
+    }
+}

package/dist/src/utils/comparers.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultComparer = defaultComparer;
+exports.identity = identity;
+function defaultComparer(a, b) {
+    if (a === b)
+        return 0;
+    if (a === null || a === undefined)
+        return -1;
+    if (b === null || b === undefined)
+        return 1;
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+function identity(item) {
+    return item;
+}

package/dist/src/utils/guards.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIterable = isIterable;
+exports.isFunction = isFunction;
+exports.assertIterable = assertIterable;
+exports.assertFunction = assertFunction;
+exports.assertInteger = assertInteger;
+exports.assertNonNegative = assertNonNegative;
+function isIterable(obj) {
+    return obj != null && typeof obj[Symbol.iterator] === 'function';
+}
+function isFunction(obj) {
+    return typeof obj === 'function';
+}
+function assertIterable(source, name = 'source') {
+    if (!isIterable(source)) {
+        throw new TypeError(`${name} must be an iterable.`);
+    }
+}
+function assertFunction(fn, name) {
+    if (!isFunction(fn)) {
+        throw new TypeError(`${name} must be a function.`);
+    }
+}
+function assertInteger(num, name) {
+    if (typeof num !== 'number' || !Number.isFinite(num) || !Number.isInteger(num)) {
+        throw new TypeError(`${name} must be a finite integer.`);
+    }
+}
+function assertNonNegative(num, name) {
+    if (num < 0) {
+        throw new TypeError(`${name} must be non-negative.`);
+    }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "inqjs",
+  "version": "1.0.0",
+  "description": "A lightweight, dependency-free LINQ engine for TypeScript and JavaScript with comprehensive query capabilities",
+  "main": "dist/src/Query.js",
+  "types": "dist/src/Query.d.ts",
+  "files": [
+    "dist/src/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "linq",
+    "query",
+    "typescript",
+    "javascript",
+    "functional",
+    "lazy-evaluation",
+    "async",
+    "json",
+    "set-operations"
+  ],
+  "author": "Parth Parikh",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ptp28/inqjs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ptp28/inqjs/issues"
+  },
+  "homepage": "https://github.com/ptp28/inqjs#readme",
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.14"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}