@vinicunca/perkakas 0.1.0 → 0.3.1

package/dist/types/string/index.d.ts

@@ -0,0 +1,6 @@
+export * from './cases';
+export * from './human-readable-file-size';
+export * from './random-string';
+export * from './slugify';
+export * from './string-to-path';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/string/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/string/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC"}

package/dist/types/string/random-string.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Random a non-cryptographic random string from characters a-zA-Z0-9.
+ * @param length the length of the random string
+ * @signature randomString(length)
+ * @example
+ *    randomString(5) // => aB92J
+ * @category String
+ */
+export declare function randomString(length: number): string;
+//# sourceMappingURL=random-string.d.ts.map

package/dist/types/string/random-string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-string.d.ts","sourceRoot":"","sources":["../../../src/string/random-string.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,UAO1C"}

package/dist/types/string/slugify.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Turn any string into a URL/DOM safe string.
+ * @param str the string to slugify
+ * @signature
+ *  P.slugify(str)
+ * @example
+ *  P.slugify('FooBar') // => 'foobar'
+ *  P.slugify('This!-is*&%#@^up!') // => 'this-is-up'
+ * @category String
+ */
+export declare function slugify(str: string): string;
+//# sourceMappingURL=slugify.d.ts.map

package/dist/types/string/slugify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slugify.d.ts","sourceRoot":"","sources":["../../../src/string/slugify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ3C"}

package/dist/types/string/string-to-path.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Converts a path string to an array of keys.
+ * @param path a string path
+ * @signature P.stringToPathArray(path)
+ * @example P.stringToPathArray('a.b[0].c') // => ['a', 'b', 0, 'c']
+ * @dataFirst
+ * @category String
+ */
+export declare function stringToPath<Path extends string>(path: Path): StringToPath<Path>;
+export type StringToPath<T extends string> = T extends '' ? [] : T extends `[${infer Head}].${infer Tail}` ? [Head, ...StringToPath<Tail>] : T extends `.${infer Head}${infer Tail}` ? [Head, ...StringToPath<Tail>] : T extends `${infer Head}${infer Tail}` ? [Head, ...StringToPath<Tail>] : [T];
+//# sourceMappingURL=string-to-path.d.ts.map

package/dist/types/string/string-to-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-to-path.d.ts","sourceRoot":"","sources":["../../../src/string/string-to-path.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,SAAS,MAAM,EAC9C,IAAI,EAAE,IAAI,GACT,YAAY,CAAC,IAAI,CAAC,CAEpB;AAiBD,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,EAAE,GACrD,EAAE,GACF,CAAC,SAAS,IAAI,MAAM,IAAI,KAAK,MAAM,IAAI,EAAE,GACvC,CAAC,IAAI,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,GAC7B,CAAC,SAAS,IAAI,MAAM,IAAI,GAAG,MAAM,IAAI,EAAE,GACrC,CAAC,IAAI,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,GAC7B,CAAC,SAAS,GAAG,MAAM,IAAI,GAAG,MAAM,IAAI,EAAE,GACpC,CAAC,IAAI,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,GAC7B,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/type/index.d.ts

@@ -0,0 +1,2 @@
+export * from './type';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/type/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/type/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC"}

package/dist/types/type/type.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Gives a single-word string description of the (native) type of a value, returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not attempt to distinguish user Object types any further, reporting them all as 'Object'.
+ * @param val
+ * @signature
+ *    P.type(obj)
+ * @example
+ *    P.type({}); //=> "Object"
+ *    P.type(1); //=> "Number"
+ *    P.type(false); //=> "Boolean"
+ *    P.type('s'); //=> "String"
+ *    P.type(null); //=> "Null"
+ *    P.type([]); //=> "Array"
+ *    P.type(/[A-z]/); //=> "RegExp"
+ *    P.type(() => {}); //=> "Function"
+ *    P.type(undefined); //=> "Undefined"
+ * @category Type
+ */
+export declare function type(val: unknown): string;
+//# sourceMappingURL=type.d.ts.map

package/dist/types/type/type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../src/type/type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,OAAO,UAUhC"}

package/dist/types/utils/heap.d.ts

@@ -0,0 +1,24 @@
+import type { CompareFunction } from './types';
+/**
+ * Mutates an array into a "max"-heap based on `compareFn` so that for any `item` in the heap, `compareFn(heap[0], item) > 0`
+ *
+ * @param heap - The array to be heapified. The array would be mutated!
+ * @param compareFn - The comparator used to order items in the heap. Use the
+ * same function in all calls mutating the same heap otherwise you'd get
+ * unexpected results.
+ */
+export declare function heapify<T>(heap: Array<T>, compareFn: CompareFunction<T>): void;
+/**
+ * Insert an item into a heap if it's "smaller" (in regards to `compareFn`) than
+ * the current head of the heap (which is the "largest" value in the heap). If
+ * the item is inserted, the previous head of the heap is returned, otherwise
+ * `undefined` is returned and the heap is unchanged.
+ *
+ * @param heap - a *mutable* array representing a heap (see `heapify`).
+ * @param compareFn - The comparator used to order items in the heap. Use the
+ * @param item - The item to be inserted into the heap.
+ * @returns `undefined` if the heap is unchanged, or the previous head of the
+ * heap if the item was inserted.
+ */
+export declare function heapMaybeInsert<T>(heap: Array<T>, compareFn: CompareFunction<T>, item: T): T | undefined;
+//# sourceMappingURL=heap.d.ts.map

package/dist/types/utils/heap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heap.d.ts","sourceRoot":"","sources":["../../../src/utils/heap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAK/C;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EACd,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,GAC5B,IAAI,CAIN;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EACd,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,EAC7B,IAAI,EAAE,CAAC,GACN,CAAC,GAAG,SAAS,CAef"}

package/dist/types/utils/narrow.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Copied from ts-toolbelt
+ * https://github.com/millsp/ts-toolbelt/blob/master/sources/Function/Narrow.ts
+ */
+/**
+ * Similar to [[Cast]] but with a custom fallback `Catch`. If it fails,
+ * it will enforce `Catch` instead of `A2`.
+ * @param A1 to check against
+ * @param A2 to try/test with
+ * @param Catch to fallback to if the test failed
+ * @returns `A1 | Catch`
+ * @example
+ * ```ts
+ * import {A} from 'ts-toolbelt'
+ *
+ * type test0 = A.Try<'42', string>          // '42'
+ * type test1 = A.Try<'42', number>          // never
+ * type test1 = A.Try<'42', number, 'tried'> // 'tried'
+ * ```
+ */
+export type Try<A1, A2, Catch = never> = A1 extends A2 ? A1 : Catch;
+/**
+ * Describes types that can be narrowed
+ */
+export type Narrowable = bigint | boolean | number | string;
+/**
+ * @hidden
+ */
+type NarrowRaw<A> = {
+    [K in keyof A]: A[K] extends (...args: Array<any>) => any ? A[K] : NarrowRaw<A[K]>;
+} | (A extends [] ? [] : never) | (A extends Narrowable ? A : never);
+/**
+ * Prevent type widening on generic function parameters
+ * @param A to narrow
+ * @returns `A`
+ * @example
+ * ```ts
+ * import {F} from 'ts-toolbelt'
+ *
+ * declare function foo<A extends any[]>(x: F.Narrow<A>): A;
+ * declare function bar<A extends object>(x: F.Narrow<A>): A;
+ *
+ * const test0 = foo(['e', 2, true, {f: ['g', ['h']]}])
+ * // `A` inferred : ['e', 2, true, {f: ['g']}]
+ *
+ * const test1 = bar({a: 1, b: 'c', d: ['e', 2, true, {f: ['g']}]})
+ * // `A` inferred : {a: 1, b: 'c', d: ['e', 2, true, {f: ['g']}]}
+ * ```
+ */
+export type Narrow<A> = Try<A, [], NarrowRaw<A>>;
+export {};
+//# sourceMappingURL=narrow.d.ts.map

package/dist/types/utils/narrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"narrow.d.ts","sourceRoot":"","sources":["../../../src/utils/narrow.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,GAAG,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,GAAG,KAAK,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AAE5D;;GAEG;AACH,KAAK,SAAS,CAAC,CAAC,IACZ;KACC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,GAAG,GACrD,CAAC,CAAC,CAAC,CAAC,GACJ,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACpB,GACC,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,GAC3B,CAAC,CAAC,SAAS,UAAU,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;AAEvC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/types/utils/paths.d.ts

@@ -0,0 +1,9 @@
+export type Path<Obj, Prefix extends Array<PropertyKey> = []> = Obj extends Primitive ? Prefix : Obj extends Array<infer Item> ? Path<Item, [...Prefix, number]> | Prefix : PathsOfObject<Obj, Prefix> | Prefix;
+type PathsOfObject<Obj, Prefix extends Array<PropertyKey>> = {
+    [K in keyof Obj]: Path<Obj[K], [...Prefix, K]>;
+}[keyof Obj];
+export type ValueAtPath<Obj, ObjPath extends Array<PropertyKey> = []> = ObjPath extends [] ? Obj : ObjPath extends [infer Head, ...infer Tail] ? Tail extends Array<PropertyKey> ? Head extends keyof Obj ? ValueAtPath<Obj[Head], Tail> : never : never : never;
+export type SupportsValueAtPath<Obj, Path extends Array<PropertyKey>, Value> = Value extends ValueAtPath<Obj, Path> ? Obj : never;
+type Primitive = boolean | null | number | string | symbol | undefined;
+export {};
+//# sourceMappingURL=paths.d.ts.map

package/dist/types/utils/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/utils/paths.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,IAAI,CACd,GAAG,EACH,MAAM,SAAS,KAAK,CAAC,WAAW,CAAC,GAAG,EAAE,IACpC,GAAG,SAAS,SAAS,GACrB,MAAM,GACN,GAAG,SAAS,KAAK,CAAC,MAAM,IAAI,CAAC,GAC3B,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,GACxC,aAAa,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC;AAE1C,KAAK,aAAa,CAAC,GAAG,EAAE,MAAM,SAAS,KAAK,CAAC,WAAW,CAAC,IAAI;KAC1D,CAAC,IAAI,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC;CAC/C,CAAC,MAAM,GAAG,CAAC,CAAC;AAEb,MAAM,MAAM,WAAW,CACrB,GAAG,EACH,OAAO,SAAS,KAAK,CAAC,WAAW,CAAC,GAAG,EAAE,IACrC,OAAO,SAAS,EAAE,GAClB,GAAG,GACH,OAAO,SAAS,CAAC,MAAM,IAAI,EAAE,GAAG,MAAM,IAAI,CAAC,GACzC,IAAI,SAAS,KAAK,CAAC,WAAW,CAAC,GAC7B,IAAI,SAAS,MAAM,GAAG,GACpB,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,GAC5B,KAAK,GACP,KAAK,GACP,KAAK,CAAC;AAEZ,MAAM,MAAM,mBAAmB,CAC7B,GAAG,EACH,IAAI,SAAS,KAAK,CAAC,WAAW,CAAC,EAC/B,KAAK,IACH,KAAK,SAAS,WAAW,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,GAAG,GAAG,KAAK,CAAC;AAEvD,KAAK,SAAS,GAAG,OAAO,GAAG,IAAI,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC"}

package/dist/types/utils/purry-on.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utility for purrying functions based on a predicate for the first argument.
+ *
+ * This is useful for purrying functions with a variadic argument list.
+ */
+export declare function purryOn<T>(isArg: (firstArg: unknown) => firstArg is T, implementation: (firstArg: T, ...args: Array<any>) => unknown, args: any): unknown;
+//# sourceMappingURL=purry-on.d.ts.map

package/dist/types/utils/purry-on.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purry-on.d.ts","sourceRoot":"","sources":["../../../src/utils/purry-on.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,QAAQ,IAAI,CAAC,EAC3C,cAAc,EAAE,CAAC,QAAQ,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,OAAO,EAC7D,IAAI,EAAE,GAAG,GACR,OAAO,CAOT"}

package/dist/types/utils/purry-order-rules.d.ts

@@ -0,0 +1,52 @@
+import type { CompareFunction } from './types';
+declare const COMPARATORS: {
+    readonly asc: <T>(x: T, y: T) => boolean;
+    readonly desc: <T_1>(x: T_1, y: T_1) => boolean;
+};
+/**
+ * An order rule defines a projection/extractor that returns a comparable from
+ * the data being compared. It would be run on each item being compared, and a
+ * comparator would then be used on the results to determine the order.
+ *
+ * There are 2 forms of the order rule, a simple one which only provides the
+ * projection function and assumes ordering is ascending, and a 2-tuple where
+ * the first element is the projection function and the second is the direction;
+ * this allows changing the direction without defining a more complex projection
+ * to simply negate the value (e.g. `(x) => -x`).
+ *
+ * We rely on the javascript implementation of `<` and `>` for comparison, which
+ * will attempt to transform both operands into a primitive comparable value via
+ * the built in `valueOf` function (and then `toString`). It's up to the caller
+ * to make sure that the projection is returning a value that makes sense for
+ * this logic.
+ *
+ * It's important to note that there is no built-in caching/memoization of
+ * projection function and therefore no guarantee that it would only be called
+ * once.
+ */
+export type OrderRule<T> = Projection<T> | readonly [projection: Projection<T>, direction: keyof typeof COMPARATORS];
+type Projection<T> = (x: T) => Comparable;
+type Comparable = {
+    [Symbol.toPrimitive](hint: string): ComparablePrimitive;
+} | {
+    toString(): string;
+} | {
+    valueOf(): ComparablePrimitive;
+} | ComparablePrimitive;
+type ComparablePrimitive = boolean | number | string;
+/**
+ * Allows functions that want to handle a variadic number of order rules a
+ * a simplified API that hides most of the implementation details. The only
+ * thing users of this function need to do is provide a function that would take
+ * the data, and a compare function that can be used to determine the order
+ * between the items of the array.
+ * This functions takes care of the rest; it will parse rules, built the
+ * comparer, and manage the purrying of the input arguments.
+ */
+export declare function purryOrderRules<T>(func: (data: ReadonlyArray<T>, compareFn: CompareFunction<T>) => unknown, inputArgs: IArguments | ReadonlyArray<unknown>): unknown;
+/**
+ * Some functions need an extra number argument, this helps facilitate that.
+ */
+export declare function purryOrderRulesWithArgument(func: <T>(data: ReadonlyArray<T>, compareFn: CompareFunction<T>, arg: any) => unknown, inputArgs: any[]): unknown;
+export {};
+//# sourceMappingURL=purry-order-rules.d.ts.map

package/dist/types/utils/purry-order-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purry-order-rules.d.ts","sourceRoot":"","sources":["../../../src/utils/purry-order-rules.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,SAAS,CAAC;AAG9D,QAAA,MAAM,WAAW;;;CAGP,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IACnB,UAAU,CAAC,CAAC,CAAC,GACb,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,WAAW,CAAC,CAAC;AAE9E,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,KAAK,UAAU,CAAC;AAK1C,KAAK,UAAU,GACX;IAAE,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,CAAA;CAAE,GAC3D;IAAE,QAAQ,IAAI,MAAM,CAAA;CAAE,GACtB;IAAE,OAAO,IAAI,mBAAmB,CAAA;CAAE,GAClC,mBAAmB,CAAC;AAIxB,KAAK,mBAAmB,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;AAErD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,IAAI,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,OAAO,EACxE,SAAS,EAAE,UAAU,GAAG,aAAa,CAAC,OAAO,CAAC,GAC7C,OAAO,CA0BT;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,CAAC,CAAC,EACN,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACtB,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,EAC7B,GAAG,EAAE,GAAG,KACL,OAAO,EACZ,SAAS,EAAE,GAAG,EAAE,GACf,OAAO,CAiBT"}

package/dist/types/utils/quick-select.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A simple implementation of the *QuickSelect* algorithm.
+ * @see https://en.wikipedia.org/wiki/Quickselect
+ */
+import type { CompareFunction } from './types';
+/**
+ * Perform QuickSelect on the given data. Notice that the data would be cloned
+ * shallowly so that it could be mutated in-place, and then discarded once the
+ * algorithm is done. This means that running this function multiple times on
+ * the same array might be slower then sorting the array before.
+ * @param data - The data to perform the selection on.
+ * @param index - The index of the item we are looking for.
+ * @param compareFn - The compare function to use for sorting.
+ * @returns The item at the given index, or `undefined` if the index is out-of-
+ * bounds.
+ */
+export declare function quickSelect<T>(data: ReadonlyArray<T>, index: number, compareFn: CompareFunction<T>): T | undefined;
+//# sourceMappingURL=quick-select.d.ts.map

package/dist/types/utils/quick-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quick-select.d.ts","sourceRoot":"","sources":["../../../src/utils/quick-select.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI/C;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EACnD,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAY9C"}

package/dist/types/utils/reduce-lazy.d.ts

@@ -0,0 +1,22 @@
+export type LazyResult<T> = LazyEmpty | LazyMany<T> | LazyNext<T>;
+interface LazyEmpty {
+    done: boolean;
+    hasMany?: false | undefined;
+    hasNext: false;
+    next?: undefined;
+}
+interface LazyNext<T> {
+    done: boolean;
+    hasMany?: false | undefined;
+    hasNext: true;
+    next: T;
+}
+interface LazyMany<T> {
+    done: boolean;
+    hasMany: true;
+    hasNext: true;
+    next: Array<T>;
+}
+export declare function reduceLazy<T, K>(array: ReadonlyArray<T>, lazy: (item: T, index?: number, array?: ReadonlyArray<T>) => LazyResult<K>, indexed?: boolean): Array<K>;
+export {};
+//# sourceMappingURL=reduce-lazy.d.ts.map

package/dist/types/utils/reduce-lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce-lazy.d.ts","sourceRoot":"","sources":["../../../src/utils/reduce-lazy.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAElE,UAAU,SAAS;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;IAC5B,OAAO,EAAE,KAAK,CAAC;IACf,IAAI,CAAC,EAAE,SAAS,CAAC;CAClB;AAED,UAAU,QAAQ,CAAC,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC;IAC5B,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE,CAAC,CAAC;CACT;AAED,UAAU,QAAQ,CAAC,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,IAAI,CAAC;IACd,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;CAChB;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAC7B,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,EAC1E,OAAO,CAAC,EAAE,OAAO,GAChB,KAAK,CAAC,CAAC,CAAC,CAaV"}

package/dist/types/utils/swap-in-place.d.ts

@@ -0,0 +1,5 @@
+/**
+ * An efficient hack to swap the values at two indices in an array *in-place*.
+ */
+export declare function swapInPlace(data: Array<unknown>, i: number, j: number): void;
+//# sourceMappingURL=swap-in-place.d.ts.map

package/dist/types/utils/swap-in-place.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap-in-place.d.ts","sourceRoot":"","sources":["../../../src/utils/swap-in-place.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAI5E"}

package/dist/types/utils/to-lazy-indexed.d.ts

@@ -0,0 +1,4 @@
+export declare function toLazyIndexed<Func extends (...args: any) => unknown>(fn: Func): Func & {
+    readonly indexed: true;
+};
+//# sourceMappingURL=to-lazy-indexed.d.ts.map

package/dist/types/utils/to-lazy-indexed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-lazy-indexed.d.ts","sourceRoot":"","sources":["../../../src/utils/to-lazy-indexed.ts"],"names":[],"mappings":"AAAA,wBAAgB,aAAa,CAAC,IAAI,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,OAAO,EAAE,EAAE,EAAE,IAAI,GAAG,IAAI,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAA;CAAE,CAEjH"}

package/dist/types/utils/to-single.d.ts

@@ -0,0 +1,4 @@
+export declare function toSingle<T>(fn: T): T & {
+    single: true;
+};
+//# sourceMappingURL=to-single.d.ts.map

package/dist/types/utils/to-single.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-single.d.ts","sourceRoot":"","sources":["../../../src/utils/to-single.ts"],"names":[],"mappings":"AAAA,wBAAgB,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG;IAAE,MAAM,EAAE,IAAI,CAAA;CAAE,CAGvD"}

package/dist/types/utils/types.d.ts

@@ -0,0 +1,32 @@
+import type { IsAny } from 'type-fest';
+export type Pred<T, K> = (input: T) => K;
+export type PredIndexed<T, K> = (input: T, index: number, array: Array<T>) => K;
+export type PredIndexedOptional<T, K> = (input: T, index?: number, array?: ReadonlyArray<T>) => K;
+export type NonEmptyArray<T> = [T, ...Array<T>];
+/**
+ * This should only be used for defining generics which extend any kind of JS
+ * array under the hood, this includes arrays *AND* tuples (of the form [x, y],
+ * and of the form [x, ...y[]], etc...), and their readonly equivalent. This
+ * allows us to be more inclusive to what functions can process.
+ *
+ * @example map<T extends ArrayLike>(items: T) { ... }
+ *
+ * We would've named this `ArrayLike`, but that's already used by typescript...
+ *
+ * @see This was inspired by the type-definition of Promise.all (https://github.com/microsoft/TypeScript/blob/1df5717b120cddd325deab8b0f2b2c3eecaf2b01/src/lib/es2015.promise.d.ts#L21)
+ */
+export type IterableContainer<T = unknown> = [] | ReadonlyArray<T>;
+/**
+ * A compare function that is compatible with the native `Array.sort` function.
+ * @returns >0 if `a` should come after `b`, 0 if they are equal, and <0 if `a` should come before `b`.
+ */
+export type CompareFunction<T> = (a: T, b: T) => number;
+export type ObjectKeys<T extends object> = `${Exclude<keyof T, symbol>}`;
+/**
+ * An extension of Extract for type predicates which falls back to the base
+ * in order to narrow the `unknown` case.
+ * @example
+ *   function isMyType<T>(data: T | MyType): data is NarrowedTo<T, MyType> { ... }
+ */
+export type NarrowedTo<T, Base> = Extract<T, Base> extends never ? Base : IsAny<T> extends true ? Base : Extract<T, Base>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AAEvC,MAAM,MAAM,IAAI,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,CAAC;AACzC,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AAChF,MAAM,MAAM,mBAAmB,CAAC,CAAC,EAAE,CAAC,IAAI,CACtC,KAAK,EAAE,CAAC,EACR,KAAK,CAAC,EAAE,MAAM,EACd,KAAK,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,KACrB,CAAC,CAAC;AAEP,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;AAEhD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,OAAO,IAAI,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;AAEnE;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC;AAIxD,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC;AAEzE;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,IAAI,IAC5B,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,KAAK,GAC1B,IAAI,GACJ,KAAK,CAAC,CAAC,CAAC,SAAS,IAAI,GACnB,IAAI,GACJ,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC"}

package/dist/types/utils/with-precision.d.ts

@@ -0,0 +1,2 @@
+export declare function withPrecision(roundingFn: (value: number) => number): (value: number, precision: number) => number;
+//# sourceMappingURL=with-precision.d.ts.map

package/dist/types/utils/with-precision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-precision.d.ts","sourceRoot":"","sources":["../../../src/utils/with-precision.ts"],"names":[],"mappings":"AAKA,wBAAgB,aAAa,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,WAClD,MAAM,aAAa,MAAM,YAqBzC"}

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "@vinicunca/perkakas",
   "type": "module",
-  "version": "0.1.0",
+  "version": "0.3.1",
+  "packageManager": "pnpm@8.10.5",
   "description": "Utility for JavaScript and Typescript.",
-  "author": {
-    "name": "praburangki",
-    "email": "praburangki@gmail.com",
-    "url": "https://praburangki.dev"
-  },
+  "author": "praburangki<https://github.com/praburangki>",
   "license": "MIT",
   "homepage": "https://github.com/vinicunca/perkakas#readme",
   "repository": {
@@ -25,33 +22,47 @@
     "javascript helpers",
     "typescript helpers"
   ],
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
-  },
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "main": "dist/commonjs/index.js",
+  "module": "dist/es/index.js",
+  "jsnext:main": "dist/es/index.js",
+  "types": "dist/types/index.d.ts",
   "files": [
-    "dist"
+    "dist/*"
   ],
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "devDependencies": {
+    "@tsconfig/recommended": "^1.0.3",
     "@types/fs-extra": "^11.0.4",
-    "@vitest/coverage-v8": "^1.1.0",
+    "@vinicunca/eslint-config": "^2.1.5",
+    "@vitest/coverage-v8": "^1.3.1",
+    "bumpp": "^9.3.1",
+    "eslint": "^8.57.0",
     "fs-extra": "^11.2.0",
-    "tsup": "^8.0.1",
-    "typedoc": "^0.25.4"
+    "is-ci": "^3.0.1",
+    "prettier": "^3.2.5",
+    "rimraf": "^5.0.5",
+    "tiny-invariant": "^1.3.3",
+    "type-fest": "^4.10.3",
+    "typedoc": "^0.25.10",
+    "typescript": "^5.3.3",
+    "vitest": "^1.3.1"
   },
   "scripts": {
-    "stub": "tsup src/index.ts --format esm",
-    "lint": "pnpm run stub && eslint . --fix",
-    "test:coverage": "vitest run --coverage",
     "test": "vitest",
-    "build": "tsup src/index.ts --format esm,cjs --clean --dts",
-    "release": "bumpp package.json --commit --push --tag --commit 'chore: release v'"
+    "test:coverage": "vitest run --coverage",
+    "postinstall": "is-ci || pnpm -r run stub",
+    "prepublish": "pnpm run build",
+    "release": "bumpp package.json --commit --push --tag --commit 'chore: release v'",
+    "typedoc": "typedoc --json dist/metadata.json",
+    "build": "pnpm run clean && pnpm run build:es && pnpm run build:cjs && npm run build:types && pnpm run typedoc",
+    "build:cjs": "tsc --project tsconfig.build.json --module commonjs --outDir \"./dist/commonjs\"",
+    "build:es": "tsc --project tsconfig.build.json --module esnext --outDir \"./dist/es\"",
+    "build:types": "tsc --project tsconfig.build.types.json --outDir \"./dist/types\"",
+    "clean": "rm -rf ./dist && mkdir dist",
+    "lint": "pnpm run stub && eslint . --fix",
+    "registry": "pnpm publish --access public --no-git-checks"
   }
 }