iterable-linq-utility 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2022] [Federico Maria Ceruti]
+
+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/dist/filter.d.ts

@@ -0,0 +1 @@
+export declare function filter<T>(iterable: Iterable<T>, predicate: (value: T, index: number) => boolean): Iterable<T>;

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export interface ILinqIterable<T> {
+    [Symbol.iterator](): Iterator<T, any, undefined>;
+    collectToArray(): T[];
+    filter(predicate: (value: T, index: number) => boolean): ILinqIterable<T>;
+    map<R>(mapper: (value: T, index: number) => R): ILinqIterable<R>;
+    materialize(): ILinqIterable<T>;
+    max<T>(comparer?: (a: T, b: T, index: number) => boolean): T | null | undefined;
+    memoize(): ILinqIterable<T>;
+    some(predicate: (value: T, index: number) => boolean): boolean;
+}
+declare module "./linqIterable" {
+    interface LinqIterable<T> {
+        filter(predicate: (value: T, index: number) => boolean): ILinqIterable<T>;
+        map<R>(mapper: (value: T, index: number) => R): ILinqIterable<R>;
+        materialize(): ILinqIterable<T>;
+        max<T>(comparer?: (a: T, b: T, index: number) => boolean): T | null | undefined;
+        memoize(): ILinqIterable<T>;
+        some(predicate: (value: T, index: number) => boolean): boolean;
+    }
+}
+export declare function from<T>(iterable: Iterable<T>): ILinqIterable<T>;

package/dist/interable-linq-utility.js

@@ -0,0 +1,261 @@
+var S = Object.defineProperty;
+var y = (e, t, r) => t in e ? S(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var o = (e, t, r) => (y(e, typeof t != "symbol" ? t + "" : t, r), r);
+class u {
+  constructor(t) {
+    o(this, "iterable");
+    this.iterable = t;
+  }
+  [Symbol.iterator]() {
+    return this.iterable[Symbol.iterator]();
+  }
+  source() {
+    return this.iterable;
+  }
+  collectToArray() {
+    return [...this.source()];
+  }
+}
+function b(e, t) {
+  return (r, i) => t(e(r, i), i);
+}
+function w(e, t) {
+  return (r, i) => t(r, i) && e(r, i);
+}
+function L(e) {
+  return typeof e == "function";
+}
+function f(e, t) {
+  return {
+    done: e,
+    value: t
+  };
+}
+function p() {
+  return { done: !0, value: void 0 };
+}
+function M(e, t) {
+  return new l(e, t);
+}
+class l {
+  constructor(t, r) {
+    o(this, "predicate");
+    o(this, "source");
+    let i = r, n = t;
+    if (n instanceof l) {
+      const s = n.predicate;
+      n = n.source, i = w(s, i);
+    }
+    this.source = n, this.predicate = i;
+  }
+  [Symbol.iterator]() {
+    return new k(this.source, this.predicate);
+  }
+}
+class k {
+  constructor(t, r) {
+    o(this, "index", 0);
+    o(this, "sourceIterator");
+    o(this, "predicate");
+    this.sourceIterator = t[Symbol.iterator](), this.predicate = r;
+  }
+  next() {
+    for (; ; ) {
+      const t = this.sourceIterator.next();
+      if (t.done === !0 || this.predicate(t.value, this.index++))
+        return t;
+    }
+  }
+}
+function v(e, t) {
+  return new h(e, t);
+}
+class h {
+  constructor(t, r) {
+    o(this, "mapper");
+    o(this, "source");
+    let i = r, n = t;
+    if (n instanceof h) {
+      const s = n.mapper;
+      n = n.source, i = b(s, i);
+    }
+    this.source = t, this.mapper = i;
+  }
+  [Symbol.iterator]() {
+    return new N(this.source, this.mapper);
+  }
+}
+class N {
+  constructor(t, r) {
+    o(this, "index", 0);
+    o(this, "sourceIterator");
+    o(this, "mapper");
+    this.sourceIterator = t[Symbol.iterator](), this.mapper = r;
+  }
+  next() {
+    const t = this.sourceIterator.next();
+    return t.done !== !0 ? f(!1, this.mapper(t.value, this.index++)) : p();
+  }
+}
+function A(e) {
+  const t = e[Symbol.iterator](), r = new a();
+  for (let i = t.next(); i.done !== !0; i = t.next())
+    r.addLast(i.value);
+  return r;
+}
+class F {
+  constructor(t = null) {
+    o(this, "current", null);
+    this.current = t;
+  }
+  next() {
+    const t = this.current;
+    return t === null ? p() : (this.current = t.nextNode, f(!1, t.data));
+  }
+}
+class a {
+  constructor() {
+    o(this, "internalSize", 0);
+    o(this, "head", null);
+    o(this, "tail", null);
+  }
+  [Symbol.iterator]() {
+    return new F(this.head);
+  }
+  addFirst(t) {
+    const r = {
+      data: t,
+      nextNode: null
+    };
+    switch (this.internalSize) {
+      case 0:
+        this.head = r, this.tail = r;
+        break;
+      default:
+        r.nextNode = this.head, this.head = r;
+    }
+    return this.internalSize++, this;
+  }
+  addLast(t) {
+    const r = {
+      data: t,
+      nextNode: null
+    };
+    switch (this.internalSize) {
+      case 0:
+        this.head = r, this.tail = r;
+        break;
+      default:
+        this.tail.nextNode = r, this.tail = r;
+    }
+    return this.internalSize++, this;
+  }
+  size() {
+    return this.internalSize;
+  }
+}
+function g(e) {
+  return e instanceof d ? e : new d(e);
+}
+class d {
+  constructor(t) {
+    o(this, "source");
+    if (t instanceof a) {
+      this.source = t;
+      return;
+    }
+    this.source = A(t);
+  }
+  [Symbol.iterator]() {
+    return new P(this.source);
+  }
+}
+class P {
+  constructor(t) {
+    o(this, "sourceIterator");
+    this.sourceIterator = t[Symbol.iterator]();
+  }
+  next() {
+    return this.sourceIterator.next();
+  }
+}
+function R(e, t) {
+  const r = e[Symbol.iterator]();
+  let i = 0, n = r.next(), s = n.value;
+  const I = L(t) ? t : (x, z) => x > z;
+  for (n = r.next(); n.done !== !0; n = r.next())
+    s = I(s, n.value, i++) ? s : n.value;
+  return s == null ? null : s;
+}
+function q(e) {
+  return e instanceof m ? e : new m(e);
+}
+class m {
+  constructor(t) {
+    o(this, "isMemoized", !1);
+    o(this, "sourceIterator");
+    o(this, "linkedList", new a());
+    o(this, "source");
+    this.source = t, this.sourceIterator = t[Symbol.iterator](), t instanceof a && (this.linkedList = t, this.isMemoized = !0);
+  }
+  [Symbol.iterator]() {
+    return this.isMemoized ? new T(this.linkedList) : new D(this.sourceIterator, this.linkedList, (t) => this.isMemoized = t.done === !0);
+  }
+}
+class D {
+  constructor(t, r, i) {
+    o(this, "index", 0);
+    o(this, "linkedList");
+    o(this, "linkedListIterator");
+    o(this, "setAsMemoized");
+    o(this, "sourceIterator");
+    this.linkedList = r, this.linkedListIterator = r[Symbol.iterator](), this.setAsMemoized = i, this.sourceIterator = t;
+  }
+  next() {
+    if (this.linkedList.size() > this.index++)
+      return this.linkedListIterator.next();
+    const t = this.sourceIterator.next();
+    return this.setAsMemoized(t) || this.linkedList.addLast(t.value), t;
+  }
+}
+class T {
+  constructor(t) {
+    o(this, "memoizedSourceIterator");
+    this.memoizedSourceIterator = t[Symbol.iterator]();
+  }
+  next() {
+    return this.memoizedSourceIterator.next();
+  }
+}
+function $(e, t) {
+  const r = e[Symbol.iterator]();
+  let i = 0;
+  for (let n = r.next(); n.done !== !0; n = r.next())
+    if (t(n.value, i++))
+      return !0;
+  return !1;
+}
+function c(e) {
+  return new u(e);
+}
+u.prototype.filter = function(e) {
+  return c(M(this.source(), e));
+};
+u.prototype.map = function(e) {
+  return c(v(this.source(), e));
+};
+u.prototype.materialize = function() {
+  return c(g(this.source()));
+};
+u.prototype.max = function(e) {
+  return R(this.source(), e);
+};
+u.prototype.memoize = function() {
+  return c(q(this.source()));
+};
+u.prototype.some = function(e) {
+  return $(this.source(), e);
+};
+export {
+  c as from
+};

package/dist/interable-linq-utility.umd.cjs

@@ -0,0 +1 @@
+(function(u,s){typeof exports=="object"&&typeof module<"u"?s(exports):typeof define=="function"&&define.amd?define(["exports"],s):(u=typeof globalThis<"u"?globalThis:u||self,s(u["interable-linq-utility"]={}))})(this,function(u){"use strict";var D=Object.defineProperty;var O=(u,s,c)=>s in u?D(u,s,{enumerable:!0,configurable:!0,writable:!0,value:c}):u[s]=c;var i=(u,s,c)=>(O(u,typeof s!="symbol"?s+"":s,c),c);class s{constructor(t){i(this,"iterable");this.iterable=t}[Symbol.iterator](){return this.iterable[Symbol.iterator]()}source(){return this.iterable}collectToArray(){return[...this.source()]}}function c(e,t){return(r,n)=>t(e(r,n),n)}function y(e,t){return(r,n)=>t(r,n)&&e(r,n)}function z(e){return typeof e=="function"}function m(e,t){return{done:e,value:t}}function p(){return{done:!0,value:void 0}}function $(e){return e}function S(e,t){return new h(e,t)}class h{constructor(t,r){i(this,"predicate");i(this,"source");let n=r,o=t;if(o instanceof h){const a=o.predicate;o=o.source,n=y(a,n)}this.source=o,this.predicate=n}[Symbol.iterator](){return new b(this.source,this.predicate)}}class b{constructor(t,r){i(this,"index",0);i(this,"sourceIterator");i(this,"predicate");this.sourceIterator=t[Symbol.iterator](),this.predicate=r}next(){for(;;){const t=this.sourceIterator.next();if(t.done===!0||this.predicate(t.value,this.index++))return t}}}function w(e,t){return new f(e,t)}class f{constructor(t,r){i(this,"mapper");i(this,"source");let n=r,o=t;if(o instanceof f){const a=o.mapper;o=o.source,n=c(a,n)}this.source=t,this.mapper=n}[Symbol.iterator](){return new L(this.source,this.mapper)}}class L{constructor(t,r){i(this,"index",0);i(this,"sourceIterator");i(this,"mapper");this.sourceIterator=t[Symbol.iterator](),this.mapper=r}next(){const t=this.sourceIterator.next();return t.done!==!0?m(!1,this.mapper(t.value,this.index++)):p()}}function M(e){const t=e[Symbol.iterator](),r=new d;for(let n=t.next();n.done!==!0;n=t.next())r.addLast(n.value);return r}class k{constructor(t=null){i(this,"current",null);this.current=t}next(){const t=this.current;return t===null?p():(this.current=t.nextNode,m(!1,t.data))}}class d{constructor(){i(this,"internalSize",0);i(this,"head",null);i(this,"tail",null)}[Symbol.iterator](){return new k(this.head)}addFirst(t){const r={data:t,nextNode:null};switch(this.internalSize){case 0:this.head=r,this.tail=r;break;default:r.nextNode=this.head,this.head=r}return this.internalSize++,this}addLast(t){const r={data:t,nextNode:null};switch(this.internalSize){case 0:this.head=r,this.tail=r;break;default:this.tail.nextNode=r,this.tail=r}return this.internalSize++,this}size(){return this.internalSize}}function v(e){return e instanceof I?e:new I(e)}class I{constructor(t){i(this,"source");if(t instanceof d){this.source=t;return}this.source=M(t)}[Symbol.iterator](){return new N(this.source)}}class N{constructor(t){i(this,"sourceIterator");this.sourceIterator=t[Symbol.iterator]()}next(){return this.sourceIterator.next()}}function g(e,t){const r=e[Symbol.iterator]();let n=0,o=r.next(),a=o.value;const R=z(t)?t:(j,q)=>j>q;for(o=r.next();o.done!==!0;o=r.next())a=R(a,o.value,n++)?a:o.value;return a==null?null:a}function A(e){return e instanceof x?e:new x(e)}class x{constructor(t){i(this,"isMemoized",!1);i(this,"sourceIterator");i(this,"linkedList",new d);i(this,"source");this.source=t,this.sourceIterator=t[Symbol.iterator](),t instanceof d&&(this.linkedList=t,this.isMemoized=!0)}[Symbol.iterator](){return this.isMemoized?new P(this.linkedList):new F(this.sourceIterator,this.linkedList,t=>this.isMemoized=t.done===!0)}}class F{constructor(t,r,n){i(this,"index",0);i(this,"linkedList");i(this,"linkedListIterator");i(this,"setAsMemoized");i(this,"sourceIterator");this.linkedList=r,this.linkedListIterator=r[Symbol.iterator](),this.setAsMemoized=n,this.sourceIterator=t}next(){if(this.linkedList.size()>this.index++)return this.linkedListIterator.next();const t=this.sourceIterator.next();return this.setAsMemoized(t)||this.linkedList.addLast(t.value),t}}class P{constructor(t){i(this,"memoizedSourceIterator");this.memoizedSourceIterator=t[Symbol.iterator]()}next(){return this.memoizedSourceIterator.next()}}function T(e,t){const r=e[Symbol.iterator]();let n=0;for(let o=r.next();o.done!==!0;o=r.next())if(t(o.value,n++))return!0;return!1}function l(e){return new s(e)}s.prototype.filter=function(e){return l(S(this.source(),e))},s.prototype.map=function(e){return l(w(this.source(),e))},s.prototype.materialize=function(){return l(v(this.source()))},s.prototype.max=function(e){return g(this.source(),e)},s.prototype.memoize=function(){return l(A(this.source()))},s.prototype.some=function(e){return T(this.source(),e)},u.from=l,Object.defineProperties(u,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}})});

package/dist/iteratorResults.d.ts

@@ -0,0 +1,3 @@
+export declare function getIteratorResult<T>(done: boolean, value?: T): IteratorResult<T>;
+export declare function getDoneIteratorResult<T>(): IteratorResult<T>;
+export declare function getFlatIteratorResult<T>(result: IteratorResult<T>): IteratorResult<T>;

package/dist/linkedList.d.ts

@@ -0,0 +1,20 @@
+export declare function from<T>(iterable: Iterable<T>): LinkedList<T>;
+export declare class LinkedListIterator<T> implements Iterator<T> {
+    private current;
+    constructor(current?: IListNode<T> | null);
+    next(): IteratorResult<T, any>;
+}
+export declare class LinkedList<T> implements Iterable<T> {
+    private internalSize;
+    private head;
+    private tail;
+    [Symbol.iterator](): Iterator<T>;
+    addFirst(value: T): this;
+    addLast(value: T): this;
+    size(): number;
+}
+interface IListNode<T> {
+    data: T;
+    nextNode: IListNode<T> | null;
+}
+export {};

package/dist/linqIterable.d.ts

@@ -0,0 +1,7 @@
+export declare class LinqIterable<T> implements Iterable<T> {
+    constructor(iterable: Iterable<T>);
+    [Symbol.iterator](): Iterator<T, any, undefined>;
+    private iterable;
+    source(): Iterable<T>;
+    collectToArray(): T[];
+}

package/dist/map.d.ts

@@ -0,0 +1 @@
+export declare function map<T, R>(iterable: Iterable<T>, mapper: (value: T, index: number) => R): Iterable<R>;

package/dist/materialize.d.ts

@@ -0,0 +1 @@
+export declare function materialize<T>(iterable: Iterable<T>): Iterable<T>;

package/dist/max.d.ts

@@ -0,0 +1 @@
+export declare function max<T>(iterable: Iterable<T>, comparer?: (a: T, b: T, index: number) => boolean): T | null | undefined;

package/dist/memoize.d.ts

@@ -0,0 +1 @@
+export declare function memoize<T>(iterable: Iterable<T>): Iterable<T>;

package/dist/min.d.ts

@@ -0,0 +1,2 @@
+import type { Comparer } from "./types";
+export declare function min<T>(iterable: Iterable<T>, comparer?: Comparer<T>): T | null | undefined;

package/dist/some.d.ts

@@ -0,0 +1 @@
+export declare function some<T>(iterable: Iterable<T>, predicate: (value: T, index: number) => boolean): boolean;

package/dist/types.d.ts

@@ -0,0 +1,5 @@
+declare type ComparerFunction<T> = (a: T, b: T, index: number) => number;
+declare type ComparingProps<T> = keyof T | Array<keyof T>;
+export declare type Comparer<T> = ComparerFunction<T> | ComparingProps<T>;
+export declare type Mapper<T, R> = (value: T, index: number) => R;
+export {};

package/dist/utils/combiners.d.ts

@@ -0,0 +1,2 @@
+export declare function combineMappers<T, R, RR>(m1: (value: T, index: number) => R, m2: (value: R, index: number) => RR): (value: T, index: number) => RR;
+export declare function combinePredicates<T>(m1: (value: T, index: number) => boolean, m2: (value: T, index: number) => boolean): (value: T, index: number) => boolean;

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './combiners';
+export * from './utils';

package/dist/utils/utils.d.ts

@@ -0,0 +1,74 @@
+export declare type BooleanComparePredicate<T> = (current: T, other: T) => boolean;
+/**
+ *
+ * @since 1.0.0
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `null`, `undefined` or `NaN`, else false.
+ * @example
+ *
+ * isNullOrUndefined(null)
+ * // => true
+ *
+ * isNullOrUndefined(undefined)
+ * // => true
+ *
+ * isNullOrUndefined()
+ * // => true
+ *
+ * const myVariable = undefined
+ * isNullOrUndefined(myVariable)
+ * // => true
+ *
+ * isNullOrUndefined('')
+ * // => false
+ *
+ */
+export declare function isNullOrUndefined(value?: any): value is null | undefined;
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * From [LoDash isFunction](https://github.com/lodash/lodash/blob/2f79053d7bc7c9c9561a30dda202b3dcd2b72b90/isFunction.js)
+ *
+ * @since 1.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * isFunction(class Any{})
+ * // => true
+ *
+ * isFunction(() => {})
+ * // => true
+ *
+ * isFunction(async () => {})
+ * // => true
+ *
+ * isFunction(function * Any() {})
+ * // => true
+ *
+ * isFunction(Math.round)
+ * // => true
+ *
+ * isFunction(/abc/)
+ * // => false
+ */
+export declare function isFunction(value?: any): value is (...args: any[]) => any;
+/**
+ *
+ * Checks if `value` is classified as a `String` primitive or object.
+ *
+ * From [LoDash isString](https://github.com/lodash/lodash/blob/master/isString.js)
+ *
+ * @since 1.0.0
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a string, else `false`.
+ * @example
+ *
+ * isString('abc')
+ * // => true
+ *
+ * isString(1)
+ * // => false
+ */
+export declare function isString(value?: any): value is string;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "iterable-linq-utility",
+  "version": "0.0.1",
+  "description": "An Iterable mutation utility inspired by .net Linq and Javascript Array interface",
+  "type": "module",
+  "main": "./dist/my-lib.umd.cjs",
+  "module": "./dist/my-lib.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/my-lib.js",
+      "require": "./dist/my-lib.umd.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && vite build",
+    "dev": "vite",
+    "lint": "eslint . --ext .js,.jsx,.ts,.tsx --ignore-path .eslintignore",
+    "lint-fix": "eslint . --ext .js,.jsx,.ts,.tsx --fix --ignore-path .eslintignore",
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Amebus/iterable-linq-utility.git"
+  },
+  "author": "Amebus",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/Amebus/iterable-linq-utility/issues"
+  },
+  "homepage": "https://github.com/Amebus/iterable-linq-utility#readme",
+  "keywords": ["linq", "itearable", "utility"],
+  "devDependencies": {
+    "@rushstack/eslint-patch": "^1.1.4",
+    "@types/node": "18.11.10",
+    "@typescript-eslint/eslint-plugin": "5.36.2",
+    "@typescript-eslint/parser": "5.36.2",
+    "@vitest/ui": "0.25.2",
+    "eslint": "8.22.0",
+    "eslint-plugin-import": "2.26.0",
+    "eslint-plugin-node": "11.1.0",
+    "eslint-plugin-promise": "6.0.1",
+    "eslint-plugin-standard": "5.0.0",
+    "typescript": "4.9.3",
+    "vite": "3.2.4",
+    "vite-plugin-dts": "1.7.1",
+    "vitest": "0.25.3"
+  }
+}