@ptolemy2002/ts-utils 3.4.0 → 3.5.1

package/README.md

@@ -221,6 +221,12 @@ This function takes an object of type `T` and a list of keys `K` and returns a n
 #### Returns
 `Omit<T, K>` - The object with the keys omitted.
 
+## Classes
+This library exports the following classes:
+
+### Collection<T>
+An abstract class representing an object that can be treated as an array, but with some methods overwritten to use a collection of this type rather than a standard array. No methods are implemented here, so it is up to the extending class to do it all. This is just a template for the extending class to ensure that it has all the necessary methods and that they return the correct types.
+
 ## Peer Dependencies
 - `is-callable^1.2.7`
 - `@ptolemy2002/ts-brand-utils^1.0.0`

package/dist/index.d.ts

@@ -79,3 +79,36 @@ export type ValuesIntersection<T> = ValueOf<{
 export type Contains<L extends unknown[], T> = L extends [...unknown[], T] ? true : L extends [T, ...unknown[]] ? true : L extends [T] ? true : false;
 export declare function omit<T extends object, K extends keyof T>(obj: T, ...keys: K[]): Omit<T, K>;
 export type ArrayWithOptional<AR extends unknown[], AO extends unknown[]> = AR | [...AR, ...AO];
+export declare abstract class Collection<T> {
+    abstract get length(): number;
+    abstract at(index: number): T | undefined;
+    abstract find(predicate: (item: T, index: number, array: Collection<T>) => boolean): T | undefined;
+    abstract findIndex(predicate: (item: T, index: number, array: Collection<T>) => boolean): number;
+    abstract indexOf(item: T, fromIndex?: number): number;
+    abstract includes(item: T, fromIndex?: number): boolean;
+    abstract some(predicate: (item: T, index: number, array: Collection<T>) => boolean): boolean;
+    abstract every(predicate: (item: T, index: number, array: Collection<T>) => boolean): boolean;
+    abstract forEach(callback: (item: T, index: number, array: Collection<T>) => void): void;
+    abstract map<U>(callback: (item: T, index: number, array: Collection<T>) => U): U[];
+    abstract filter(predicate: (item: T, index: number, array: Collection<T>) => boolean): Collection<T>;
+    abstract flat(depth?: number): Collection<T>;
+    abstract flatMap<U>(callback: (item: T, index: number, array: Collection<T>) => U | U[], depth?: number): U[];
+    abstract slice(start?: number, end?: number): Collection<T>;
+    abstract concat(...others: (T | T[] | Collection<T>)[]): Collection<T>;
+    abstract push(...items: T[]): void;
+    abstract pop(): T | undefined;
+    abstract shift(): T | undefined;
+    abstract unshift(...items: T[]): number;
+    abstract splice(start: number, deleteCount?: number, ...items: T[]): Collection<T>;
+    abstract reverse(): Collection<T>;
+    abstract sort(compareFn?: (a: T, b: T) => number): Collection<T>;
+    abstract fill(value: T, start?: number, end?: number): Collection<T>;
+    abstract [Symbol.iterator](): Iterator<T>;
+    abstract entries(): IterableIterator<[number, T]>;
+    abstract keys(): IterableIterator<number>;
+    abstract values(): IterableIterator<T>;
+    abstract reduce<U>(accumulator: U, callback: (accumulator: U, item: T, index: number, array: Collection<T>) => U): U;
+    abstract reduce(callback: (accumulator: T, item: T, index: number, array: Collection<T>) => T): T;
+    abstract reduce<U>(callback: (accumulator: U | T, item: T, index: number, array: Collection<T>) => U | T, initialValue?: U): U | T;
+    abstract toArray(): T[];
+}

package/dist/index.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
 exports.isAdvancedCondition = isAdvancedCondition;
 exports.createAdvancedCondition = createAdvancedCondition;
 exports.createSerializableAdvancedCondition = createSerializableAdvancedCondition;
@@ -111,3 +112,6 @@ function omit(obj, ...keys) {
     keys.forEach((key) => delete _[key]);
     return _;
 }
+class Collection {
+}
+exports.Collection = Collection;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/ts-utils",
-    "version": "3.4.0",
+    "version": "3.5.1",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",