litus 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Estid Felipe Lozano Reyes
+
+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,74 @@
+<!-- HEADER -->
+
+<div align="center">
+  <img src="https://raw.githubusercontent.com/estidlore/litus/main/Logo.svg" alt="Logo" width="80" height="80">
+  
+  <h2 align="center">Litus</h2>
+
+  <p align="center">
+    Commonly used utilities for JS and TS
+    <br />
+    <a href="https://github.com/estidlore/litus/issues">Report Bug</a>
+  </p>
+</div>
+
+Litus provides strongly-typed utils for:
+
+- **Arrays:** chunk, from, group, ...
+- **Math:** mean, median, mod, ...
+- **Object:** copy, entries, merge, ...
+- **Time:** convert, format, setDayTime, ...
+
+<!-- Installation -->
+
+## Installation
+
+Using npm
+
+```
+npm i litus
+```
+
+Using yarn
+
+```
+yarn add litus
+```
+
+<!-- Usage -->
+
+## Usage
+
+**Import all utils**
+
+For ES6+ or Typescript
+
+```
+import * as ls from "litus";
+```
+
+For CommonJS
+
+```
+var ls = require("litus");
+```
+
+**Import what you need only**
+
+```
+import type { Literal, TimeFormat } from "litus";
+import { arr, math, obj, Time } from "litus";
+```
+
+<!-- CONTRIBUTING -->
+
+## Contributing
+
+Feel free to open an [issue](https://github.com/estidlore/litus/issues) or fork this repo and create a pull request.
+Don't forget to give the project a star!
+
+<!-- LICENSE -->
+
+## License
+
+This package released under the [MIT License](https://github.com/estidlore/litus/blob/main/LICENSE).

package/dist/arr/index.d.ts

@@ -0,0 +1,9 @@
+import type { Primitive } from "../types";
+declare const chunk: <T>(arr: T[], size: number) => T[][];
+declare const fill: <T>(n: number, val: T) => T[];
+declare const from: <T>(n: number, mapFn: (i: number) => T) => T[];
+declare const group: <T extends object, K extends PropertyKey>(arr: T[], getKey: (obj: T) => K) => Record<K, T[]>;
+declare const groupBy: <T extends object, K extends keyof T>(arr: T[], key: T[K] extends PropertyKey ? K : never) => Record<PropertyKey & T[K], T[]>;
+declare const range: (a: number, b: number, step?: number) => number[];
+declare const unique: <T extends Primitive>(arr: T[]) => T[];
+export { chunk, fill, from, group, groupBy, range, unique };

package/dist/arr/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unique = exports.range = exports.groupBy = exports.group = exports.from = exports.fill = exports.chunk = void 0;
+var chunk = function (arr, size) {
+    return range(0, arr.length, size).map(function (i) { return arr.slice(i, i + size); });
+};
+exports.chunk = chunk;
+var fill = function (n, val) {
+    return from(n, function () { return val; });
+};
+exports.fill = fill;
+var from = function (n, mapFn) {
+    var res = Array(n);
+    var i = n;
+    while (--i >= 0) {
+        res[i] = mapFn(i);
+    }
+    return res;
+};
+exports.from = from;
+var group = function (arr, getKey) {
+    var res = {};
+    arr.forEach(function (el) {
+        var val = getKey(el);
+        if (res[val] === undefined) {
+            res[val] = [];
+        }
+        res[val].push(el);
+    });
+    return res;
+};
+exports.group = group;
+var groupBy = function (arr, key) {
+    return group(arr, function (obj) { return obj[key]; });
+};
+exports.groupBy = groupBy;
+var range = function (a, b, step) {
+    if (step === void 0) { step = 1; }
+    var n = Math.ceil((b - a) / step);
+    if (n <= 0) {
+        throw Error("Invalid range");
+    }
+    return from(n, function (i) { return a + step * i; });
+};
+exports.range = range;
+var unique = function (arr) {
+    var set = Array.from(new Set(arr));
+    var indexed = set.map(function (el) { return [el, arr.indexOf(el)]; });
+    return indexed.sort(function (a, b) { return a[1] - b[1]; }).map(function (el) { return el[0]; });
+};
+exports.unique = unique;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * as arr from "./arr";
+export * as math from "./math";
+export * as obj from "./obj";
+export * from "./obj/types";
+export { Time } from "./time";
+export * from "./time/types";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Time = exports.obj = exports.math = exports.arr = void 0;
+exports.arr = __importStar(require("./arr"));
+exports.math = __importStar(require("./math"));
+exports.obj = __importStar(require("./obj"));
+__exportStar(require("./obj/types"), exports);
+var time_1 = require("./time");
+Object.defineProperty(exports, "Time", { enumerable: true, get: function () { return time_1.Time; } });
+__exportStar(require("./time/types"), exports);
+__exportStar(require("./types"), exports);

package/dist/math/index.d.ts

@@ -0,0 +1,11 @@
+declare const add: (arr: number[], n: number) => number[];
+declare const divide: (arr: number[], n: number) => number[];
+declare const mean: (arr: number[]) => number;
+declare const median: (arr: number[]) => number;
+declare const mod: (x: number, m: number) => number;
+declare const multiply: (arr: number[], n: number) => number[];
+declare const pow: (arr: number[], n: number) => number[];
+declare const round: (arr: number[], n?: number) => number[];
+declare const subtract: (arr: number[], n: number) => number[];
+declare const sum: (arr: number[]) => number;
+export { add, divide, mean, median, mod, multiply, pow, round, subtract, sum };

package/dist/math/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sum = exports.subtract = exports.round = exports.pow = exports.multiply = exports.mod = exports.median = exports.mean = exports.divide = exports.add = void 0;
+var obj_1 = require("../obj");
+var add = function (arr, n) {
+    return arr.map(function (el) { return el + n; });
+};
+exports.add = add;
+var divide = function (arr, n) {
+    return multiply(arr, 1 / n);
+};
+exports.divide = divide;
+var mean = function (arr) {
+    return sum(arr) / arr.length;
+};
+exports.mean = mean;
+var median = function (arr) {
+    var mid = arr.length / 2;
+    var a = Math.floor(mid - 0.5);
+    var b = Math.ceil(mid + 0.5);
+    return mean((0, obj_1.copy)(arr).sort().slice(a, b));
+};
+exports.median = median;
+var mod = function (x, m) {
+    return ((x % m) + m) % m;
+};
+exports.mod = mod;
+var multiply = function (arr, n) {
+    return arr.map(function (el) { return el * n; });
+};
+exports.multiply = multiply;
+var pow = function (arr, n) {
+    return arr.map(function (el) { return Math.pow(el, n); });
+};
+exports.pow = pow;
+var round = function (arr, n) {
+    if (n === void 0) { n = 0; }
+    return arr.map(function (el) {
+        var k = Math.pow(10, n);
+        return Math.round(el * k) / k;
+    });
+};
+exports.round = round;
+var subtract = function (arr, n) {
+    return add(arr, -n);
+};
+exports.subtract = subtract;
+var sum = function (arr) {
+    return arr.reduce(function (acc, el) { return acc + el; }, 0);
+};
+exports.sum = sum;

package/dist/obj/index.d.ts

@@ -0,0 +1,8 @@
+import type { Entry, Key, Val } from "./types";
+declare const copy: <T>(obj: T) => T;
+declare const entries: <T extends object>(obj: T) => Entry<T>[];
+declare const has: (obj: object, ...keys: PropertyKey[]) => boolean;
+declare const keys: <T extends object>(obj: T) => `${Exclude<keyof T, symbol>}`[];
+declare const merge: <A extends object, B extends object>(a: A, b: B) => A & B;
+declare const vals: <T extends object>(obj: T) => Val<T>[];
+export { copy, entries, has, keys, merge, vals };

package/dist/obj/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vals = exports.merge = exports.keys = exports.has = exports.entries = exports.copy = void 0;
+var copy = function (obj) {
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    var res = Array.isArray(obj) ? [] : {};
+    entries(obj).forEach(function (_a) {
+        var key = _a[0], val = _a[1];
+        res[key] = copy(val);
+    });
+    return res;
+};
+exports.copy = copy;
+var entries = function (obj) {
+    return Object.entries(obj);
+};
+exports.entries = entries;
+var has = function (obj) {
+    var keys = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        keys[_i - 1] = arguments[_i];
+    }
+    return keys.every(function (key) { return Object.prototype.hasOwnProperty.call(obj, key); });
+};
+exports.has = has;
+var keys = function (obj) {
+    return Object.keys(obj);
+};
+exports.keys = keys;
+var merge = function (a, b) {
+    return Object.assign(copy(a), copy(b));
+};
+exports.merge = merge;
+var vals = function (obj) {
+    return Object.values(obj);
+};
+exports.vals = vals;

package/dist/obj/types.d.ts

@@ -0,0 +1,5 @@
+type Entry<T extends object> = [Key<T>, Val<T>];
+type KeyOf<T extends object> = Exclude<keyof T, symbol>;
+type Key<T extends object> = `${KeyOf<T>}`;
+type Val<T extends object> = T[KeyOf<T>];
+export type { Entry, Key, KeyOf, Val };

package/dist/obj/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/time/index.d.ts

@@ -0,0 +1,17 @@
+import type { TimeFormat, TimeFormatOptions, TimeUnit } from "./types";
+declare class Time {
+    static UNITS: Record<TimeUnit, number>;
+    static formatOptions: TimeFormatOptions;
+    static locales?: Intl.LocalesArgument;
+    private readonly date;
+    constructor(val?: number, unit?: TimeUnit);
+    static convert(val: number, from: TimeUnit, to?: TimeUnit): number;
+    add(val: number, unit?: TimeUnit): number;
+    format(mode?: TimeFormat, local?: Intl.LocalesArgument, opts?: Intl.DateTimeFormatOptions): string;
+    get(unit?: TimeUnit): number;
+    getDayTime(unit?: TimeUnit): number;
+    set(val: number, unit?: TimeUnit): number;
+    setDayTime(val: number, unit?: TimeUnit): number;
+    toDate(): Date;
+}
+export { Time };

package/dist/time/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Time = void 0;
+var obj_1 = require("../obj");
+var Time = /** @class */ (function () {
+    function Time(val, unit) {
+        if (unit === void 0) { unit = "ms"; }
+        this.date = new Date();
+        if (val !== undefined) {
+            this.set(val, unit);
+        }
+    }
+    Time.convert = function (val, from, to) {
+        if (to === void 0) { to = "ms"; }
+        var ms = Math.round(Time.UNITS[from] * val);
+        return ms / Time.UNITS[to];
+    };
+    Time.prototype.add = function (val, unit) {
+        if (unit === void 0) { unit = "ms"; }
+        return this.set(this.get(unit) + val, unit);
+    };
+    Time.prototype.format = function (mode, local, opts) {
+        if (mode === void 0) { mode = "full"; }
+        if (local === void 0) { local = Time.locales; }
+        if (opts === void 0) { opts = {}; }
+        var options = (0, obj_1.merge)(Time.formatOptions[mode], opts);
+        return this.date.toLocaleString(local, options);
+    };
+    Time.prototype.get = function (unit) {
+        if (unit === void 0) { unit = "ms"; }
+        return Time.convert(this.date.getTime(), "ms", unit);
+    };
+    Time.prototype.getDayTime = function (unit) {
+        if (unit === void 0) { unit = "ms"; }
+        return Time.convert(this.get("d") % 1, "d", unit);
+    };
+    Time.prototype.set = function (val, unit) {
+        if (unit === void 0) { unit = "ms"; }
+        return this.date.setTime(Time.convert(val, unit));
+    };
+    Time.prototype.setDayTime = function (val, unit) {
+        if (unit === void 0) { unit = "ms"; }
+        return this.add(val - this.getDayTime(unit), unit);
+    };
+    Time.prototype.toDate = function () {
+        return new Date(this.date);
+    };
+    Time.UNITS = {
+        d: 864e5,
+        h: 36e5,
+        m: 6e4,
+        ms: 1,
+        s: 1e3
+    };
+    Time.formatOptions = {
+        date: {
+            dateStyle: "medium"
+        },
+        full: {
+            dateStyle: "short",
+            timeStyle: "short"
+        },
+        time: {
+            timeStyle: "medium"
+        }
+    };
+    return Time;
+}());
+exports.Time = Time;

package/dist/time/types.d.ts

@@ -0,0 +1,4 @@
+type TimeFormat = "date" | "full" | "time";
+type TimeFormatOptions = Record<TimeFormat, Intl.DateTimeFormatOptions>;
+type TimeUnit = "d" | "h" | "m" | "ms" | "s";
+export type { TimeFormat, TimeFormatOptions, TimeUnit };

package/dist/time/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./primitives";

package/dist/types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./primitives"), exports);

package/dist/types/primitives.d.ts

@@ -0,0 +1,4 @@
+type Literal = boolean | number | string;
+type Nullish = null | undefined;
+type Primitive = Literal | bigint | symbol;
+export type { Literal, Nullish, Primitive };

package/dist/types/primitives.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "litus",
+  "version": "1.0.0",
+  "description": "Commonly used utilities for JS and TS",
+  "author": {
+    "email": "estidlore@outlook.com",
+    "name": "Estid Felipe Lozano Reyes",
+    "url": "https://github.com/estidlore"
+  },
+  "bugs": {
+    "url": "https://github.com/estidlore/litus/issues"
+  },
+  "files": [
+    "dist"
+  ],
+  "homepage": "https://github.com/estidlore/litus#readme",
+  "keywords": [
+    "array",
+    "date",
+    "javascript",
+    "math",
+    "object",
+    "time",
+    "typescript",
+    "utils"
+  ],
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "url": "https://github.com/estidlore/litus",
+    "type": "git"
+  },
+  "scripts": {
+    "build": "rm -rf ./dist && tsc -p tsconfig.prod.json && npm pack",
+    "format": "prettier --write .",
+    "lint": "eslint --ext .ts src --fix",
+    "test": "jest"
+  },
+  "types": "dist/index.d.ts",
+  "devDependencies": {
+    "@types/jest": "^29.4.0",
+    "@typescript-eslint/parser": "^5.52.0",
+    "eslint": "^8.34.0",
+    "eslint-config-estidlore": "github:estidlore/eslint-config-estidlore",
+    "jest": "^29.4.3",
+    "prettier": "^2.8.4",
+    "ts-jest": "^29.0.5",
+    "typescript": "^4.9.5"
+  }
+}