linqx 0.2.0 → 0.2.1

package/README.md

@@ -1,151 +1,169 @@
 # linqx
 
-Fork of the original [linq](https://github.com/mihaifm/linq) for JavaScript, updated with modern improvements and API changes.
+Modern fork of the original [linq](https://github.com/mihaifm/linq) for JavaScript.
 
-It contains all the original .NET methods plus a few additions.
+linqx keeps the familiar LINQ-style API while adding modern exports, new utility methods, improved TypeScript support, and active maintenance.
 
-Written in pure JavaScript with no dependencies.
+Written in pure JavaScript with no runtime dependencies.
 
-## Examples
+---
 
-```js
-// C# LINQ - delegate
-Enumerable.Range(1, 10)
-    .Where(delegate(int i) { return i % 3 == 0; })
-    .Select(delegate(int i) { return i * 10; });
+# Key Differences from linq
 
-// linq.js - anonymous function
-Enumerable.range(1, 10)
-    .where(function(i) { return i % 3 == 0; })
-    .select(function(i) { return i * 10; });
-```
-
-```js
-// C# LINQ - lambda
-Enumerable.Range(1, 10).Where((i) => i % 3 == 0).Select((i) => i * 10);
+## 1. Named Export Added
 
-// linq.js - arrow function
-Enumerable.range(1, 10).where((i) => i % 3 == 0).select((i) => i * 10);
-```
+The original package only exposed a default export.
 
-```js
-// C# LINQ - anonymous type
-array.Select((val, i) => new { Value: val, Index: i }());
+linqx also provides:
 
-// linq.js - object literal
-Enumerable.from(array).select((val, i) => ({ value: val, index: i }));
+```ts
+export { Enumerable };
 ```
 
-See [sample/tutorial.js](https://github.com/mihaifm/linq/blob/master/sample/tutorial.js) and the [test](https://github.com/mihaifm/linq/tree/master/test) folder for more examples.
-
-# Usage
-
-## Node.js (ES modules)
+This makes extensions, wrappers, and custom integrations cleaner and more flexible for `typescript`.
 
-Install the latest version of the library with npm:
+Example:
 
-    npm install linq
-
-Load it in your code with the `import` syntax:
+```ts
+// enumerable.extensions.ts
+import { Enumerable } from "linqx";
 
-```js
-import Enumerable from 'linq'
+declare module "linqx" {
+  namespace Enumerable {
+    export function crossJoin<T>(this: Enumerable.IEnumerable<T>): Enumerable.IEnumerable<{ left: T; right: T; }>;
+  }
+}
 
-let result = Enumerable.range(1, 10).where(i => i % 3 == 0).select(i => i * 10)
-console.log(result.toArray()) // [ 30, 60, 90 ]
+Enumerable.prototype.crossJoin = function <T>(this: Enumerable.IEnumerable<T>): Enumerable.IEnumerable<{ left: T; right: T; }> {
+  return Enumerable.from(crossJoinIterator(this));
+
+  function* crossJoinIterator(enumerable: Enumerable.IEnumerable<T>): Iterable<{ left: T; right: T; }> {
+    for (const item of enumerable) {
+      for (const otherItem of enumerable) {
+        yield { left: item, right: otherItem };
+      }
+    }
+  }
+};
 ```
 
-Because the library is an ES module, this code will only work if your project is also configured as an ES module. Add the following line in your `package.json` to make it an ES module:
+Useful when augmenting prototypes or writing reusable helpers.
 
-```json
-"type": "module"
-```
+---
 
-If you're not planning to use ES modules, check the CommonJS section below.
+## 2. Additional APIs
 
-## Node.js (CommonJS modules)
+linqx adds practical methods not available in the original package.
 
-Install version 3 of this library:
 
-    npm install linq@3
+```ts
+whereIf(flag, predicate)
+page(pageNumber, pageSize)
+page({ pageNumber, pageSize })
+joinWith(separator)
+toMap(keySelector, valueSelector)
+chunk(size)
+index()
+position()
+withNeighbors()
+```
 
-Load it with the `require` syntax:
+---
 
-```js
-const Enumerable = require('linq')
+# Installation
 
-let count = Enumerable.range(1, 10).count(i => i < 5)
-console.log(count) // 4
+```bash
+npm install linqx
 ```
 
-The [cjs](https://github.com/mihaifm/linq/tree/cjs) branch contains the source code for the CommonJS version of the library.
+---
 
-## TypeScript
+# Usage
 
-Install the latest version of the library with npm.
+## ES Modules 
 
-Configure your compiler options in `tsconfig.json`
+```ts
+import Enumerable from "linqx";
 
-```json
-"compilerOptions": {
-    "target": "ES2020",
-    "moduleResolution": "node"
-}
+const result = Enumerable
+  .range(1, 10)
+  .where(x => x % 3 === 0)
+  .select(x => x * 10)
+  .toArray();
 ```
 
-The library comes with a `d.ts` file containing type definitions for all the objects and methods, feel free to use them in your code:
+---
+
+## Named Export
 
 ```ts
-import Enumerable from 'linq';
+import { Enumerable } from "linqx";
 
-type tnum = Enumerable.IEnumerable<number>;
-let x: tnum = Enumerable.from([1, 2, 3]);
+const values = Enumerable.from([1, 2, 3]);
 ```
 
-## Deno
+---
 
-Import the library from deno.land. Use the `@deno-types` annotation to load type definitions:
+## TypeScript
 
 ```ts
-// @deno-types="https://deno.land/x/linq@4.0.0/linq.d.ts"
-import Enumerable from 'https://deno.land/x/linq@4.0.0/linq.js'
+import Enumerable from "linqx";
 
-let radius = Enumerable.toInfinity(1).where(r => r * r * Math.PI > 10000).first()
+const items: Enumerable.IEnumerable<number> = Enumerable.from([1, 2, 3]);
 ```
+---
 
-You can also install locally with npm. Use the full file path when importing the library:
+## New API Examples
 
 ```ts
-// @deno-types="./node_modules/linq/linq.d.ts"
-import Enumerable from './node_modules/linq/linq.js'
-```
+// whereIf
+Enumerable
+  .from([1, 2, 3, 4])
+  .whereIf(true, x => x > 2)
+  .toArray();
+
+// chunk
+Enumerable
+  .from([1, 2, 3, 4, 5])
+  .chunk(2)
+  .toArray();
+// result: [[1, 2], [3, 4], [5]]
+
+// withNeighbors
+for (const { prev, item, next } of Enumerable.from([10, 20, 30]).withNeighbors()) {
+}
 
-## Browser
+// position
+for (const { index, item, isFirst, isLast } of Enumerable.from(["a", "b", "c"]).position()) {  
+}
+```
+---
 
-The minified version of the library is available in the [release](https://github.com/mihaifm/linq/releases/latest) archive.
+# Migration from linq
 
-Load it via `<script type="module">`:
+Most projects can switch directly:
 
-```html
-<script type="module" src="./linq.min.js"></script>
-<script type="module">
-    import Enumerable from './linq.min.js'
-    Enumerable.from([1, 2, 3]).forEach(x => console.log(x))
-</script>
+```diff
+-import Enumerable from "linq";
++import Enumerable from "linqx";
 ```
 
-You can also load the library via a CDN:
+---
+
+# Repository
 
-|        CDN | URL                                        |
-| ---------: | :----------------------------------------- |
-| unpkg      | <https://unpkg.com/linq/>                  |
-| jsDelivr   | <https://jsdelivr.com/package/npm/linq>    |
-| packd      | <https://bundle.run/linq@latest?name=linq> |
+https://github.com/huoshan12345/linqx
+
+---
 
 # Credits
 
-[Yoshifumi Kawai](https://github.com/neuecc) developed the [original version](https://github.com/neuecc/linq.js/) of this library.
+Based on the original work by Yoshifumi Kawai and later linq maintainers.
+
+Independent community fork.
+
+---
 
 # License
 
-[MIT License](https://github.com/mihaifm/linq/blob/master/LICENSE)
+MIT

package/package.json

@@ -3,7 +3,7 @@
   "author": "huoshan12345",
   "description": "Modern fork of linq with more APIs",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "license": "MIT",
   "homepage": "https://github.com/huoshan12345/linqx",
   "repository": {