atomic-fns 0.1.0

package/build/math.js

@@ -0,0 +1,67 @@
+import { call, isFunc } from './globals.js';
+import { comp } from './operators.js';
+export function abs(x) {
+    const op = call(x, 'abs');
+    if (op != null)
+        return op;
+    return Math.abs(x);
+}
+/**
+ * Returns a tuple like (x / y, x % y)
+ * @export
+ * @param {number} x
+ * @param {number} y
+ * @return {number[]}
+ */
+export function divmod(x, y) {
+    return [Math.floor(x / y), x % y];
+}
+export function log2(x) {
+    if (x > 0) {
+        return Math.log(x) * 1.442695;
+    }
+    return Number.NaN;
+}
+export function logBase(x, y) {
+    if (x > 0 && y > 0) {
+        return Math.log(y) / Math.log(x);
+    }
+    return Number.NaN;
+}
+/** First argument can be a comparer func */
+export function min(args) {
+    // Uses `le` by default
+    let cmp = comp;
+    if (isFunc(args[0])) {
+        cmp = args.shift();
+    }
+    let res = args[0];
+    for (const x of args) {
+        if (cmp(x, res) === -1) {
+            res = x;
+        }
+    }
+    return res;
+}
+/** First argument can be a comparer func */
+export function max(args) {
+    // Uses ge by default
+    let cmp = comp;
+    if (isFunc(args[0])) {
+        cmp = args.shift();
+    }
+    let res = args[0];
+    for (const x of args) {
+        if (cmp(x, res) === 1) {
+            res = x;
+        }
+    }
+    return res;
+}
+export function sum(args) {
+    let total = 0;
+    for (const x of args) {
+        total += x;
+    }
+    return total;
+}

package/build/objects.js

@@ -0,0 +1 @@
+"use strict";

package/build/operators.d.ts

@@ -0,0 +1,29 @@
+export declare const id: (x: any) => any;
+export declare const bool: (x: any) => boolean;
+export declare const not: (x: any) => boolean;
+export declare const isinstance: (x: any, y: any) => boolean;
+export declare const all: (arr: any[], fn?: (x: any) => boolean) => boolean;
+export declare const any: (arr: any[], fn?: (x: any) => boolean) => boolean;
+export declare const and: (arr: any[], fn?: (x: any) => boolean) => boolean;
+export declare const or: (arr: any[], fn?: (x: any) => boolean) => boolean;
+export declare function comp(x: any, y: any): any;
+export declare function eq(x: any, y: any): any;
+export declare function shallowEqual(x: any, y: any): any;
+export declare function lt(x: any, y: any): any;
+export declare function le(x: any, y: any): any;
+export declare function gt(x: any, y: any): any;
+export declare function ge(x: any, y: any): any;
+export declare function add(x: any, y: any): any;
+export declare function sub(x: any, y: any): any;
+export declare function mult(x: any, y: any): any;
+export declare function div(x: any, y: any): any;
+export declare function mod(x: any, y: any): any;
+/**
+ * Calculates `x` to the power of `y`. If `x` implements a custom `pow` operator
+ * it will return `x.pow(y)`.
+ * @export
+ * @param {*} x
+ * @param {*} y
+ * @return `x` raised to the power `y`
+ */
+export declare function pow(x: any, y: any): any;

package/build/operators.js

@@ -0,0 +1,128 @@
+import { call, isNumber, isObject } from './globals.js';
+export const id = (x) => x;
+export const bool = (x) => !!x;
+export const not = (x) => !x;
+export const isinstance = (x, y) => x instanceof y;
+export const all = (arr, fn = bool) => arr.every(fn);
+export const any = (arr, fn = bool) => arr.some(fn);
+export const and = all;
+export const or = any;
+export function comp(x, y) {
+    const op = call(x, 'compare', y);
+    if (isNumber(op))
+        return op;
+    if (eq(x, y))
+        return 0;
+    if (le(x, y))
+        return -1;
+    if (ge(x, y))
+        return 1;
+    return 0;
+}
+export function eq(x, y) {
+    const op = call(x, 'eq', y);
+    if (op != null)
+        return op;
+    return x === y;
+}
+export function shallowEqual(x, y) {
+    if (!x || !y)
+        return x === y;
+    if (Array.isArray(x)) {
+        for (let i = 0; i < x.length; i++) {
+            if (!eq(x[i], y[i]))
+                return false;
+        }
+        return true;
+    }
+    if (isObject(x)) {
+        if (eq(x, y))
+            return true;
+        for (const key in x) {
+            if (!eq(x[key], y[key]))
+                return false;
+        }
+        return true;
+    }
+    return eq(x, y);
+}
+export function lt(x, y) {
+    const op = call(x, 'lt', y);
+    if (op != null)
+        return op;
+    return x < y;
+}
+export function le(x, y) {
+    let op = call(x, 'le', y);
+    if (op != null)
+        return op;
+    op = call(x, 'eq', y);
+    if (op === true)
+        return op;
+    op = call(x, 'lt', y);
+    if (op != null)
+        return op;
+    return x <= y;
+}
+export function gt(x, y) {
+    const op = call(x, 'gt', y);
+    if (op != null)
+        return op;
+    return x > y;
+}
+export function ge(x, y) {
+    let op = call(x, 'ge', y);
+    if (op != null)
+        return op;
+    op = call(x, 'eq', y);
+    if (op === true)
+        return op;
+    op = call(x, 'gt', y);
+    if (op != null)
+        return op;
+    return x >= y;
+}
+export function add(x, y) {
+    const op = call(x, 'add', y);
+    if (op != null)
+        return op;
+    return x + y;
+}
+export function sub(x, y) {
+    const op = call(x, 'sub', y);
+    if (op != null)
+        return op;
+    return x - y;
+}
+export function mult(x, y) {
+    const op = call(x, 'mult', y);
+    if (op != null)
+        return op;
+    return x * y;
+}
+export function div(x, y) {
+    const op = call(x, 'div', y);
+    if (op != null)
+        return op;
+    return x / y;
+}
+export function mod(x, y) {
+    const op = call(x, 'mod', y);
+    if (op != null)
+        return op;
+    return x % y;
+}
+/**
+ * Calculates `x` to the power of `y`. If `x` implements a custom `pow` operator
+ * it will return `x.pow(y)`.
+ * @export
+ * @param {*} x
+ * @param {*} y
+ * @return `x` raised to the power `y`
+ */
+export function pow(x, y) {
+    const op = call(x, 'pow', y);
+    if (op != null)
+        return op;
+    return x ** y;
+}

package/build/random.d.ts

@@ -0,0 +1,5 @@
+export declare const random: (min?: number, max?: number) => number;
+export declare const randomInt: (min?: number, max?: number) => number;
+export declare const choice: (arr: any[]) => any;
+export declare function sample(arr: any[], k: number): any[] | undefined;
+export declare function shuffle(arr: any): void;

package/build/random.js

@@ -0,0 +1,28 @@
+import { isObject, round } from './globals';
+export const random = (min = 0, max = 1) => Math.random() * (max - min) + min;
+export const randomInt = (min = 0, max = 1) => round(random(min, max), 0);
+export const choice = (arr) => {
+    if (!arr?.length)
+        return;
+    const index = randomInt(0, arr.length - 1);
+    return arr[index];
+};
+export function sample(arr, k) {
+    if (!arr?.length)
+        return;
+    const result = [];
+    while (k--)
+        result.push(choice(arr));
+    return result;
+}
+export function shuffle(arr) {
+    if (isObject(arr))
+        arr = Object.values(arr);
+    const n = arr.length - 1;
+    for (let i = n; i > 0; i--) {
+        const j = randomInt(0, i);
+        const temp = arr[j];
+        arr[j] = arr[i];
+        arr[i] = temp;
+    }
+}

package/build/strings.js

@@ -0,0 +1 @@
+"use strict";

package/build/util.js

@@ -0,0 +1 @@
+"use strict";

package/jasmine.json

@@ -0,0 +1,14 @@
+{
+  "reporters": [
+    {
+      "name": "jasmine-spec-reporter#SpecReporter",
+      "options": {
+        "displayStacktrace": "all"
+      }
+    }
+  ],
+  "spec_dir": "tests",
+  "spec_files": [
+    "**/*spec.ts"
+  ]
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "atomic-fns",
+  "description": "A general-purpose and forward looking toolbox for evergreen JS code standards.",
+  "version": "0.1.0",
+  "main": "build/index.js",
+  "type": "module",
+  "devDependencies": {
+    "@types/jasmine": "^4.3.0",
+    "@typescript-eslint/eslint-plugin": "^5.39.0",
+    "eslint": "^8.25.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-config-standard-with-typescript": "^23.0.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-n": "^15.3.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-promise": "^6.0.1",
+    "husky": "^8.0.1",
+    "jasmine": "^4.4.0",
+    "jasmine-spec-reporter": "^7.0.0",
+    "lint-staged": "^13.0.3",
+    "prettier": "^2.7.1",
+    "pretty-quick": "^3.1.3",
+    "ts-node": "^10.4.1",
+    "typescript": "^4.8.4"
+  },
+  "scripts": {
+    "postinstall": "npm run tsc",
+    "test": "NODE_OPTIONS=--loader=ts-node/esm jasmine --config=jasmine.json",
+    "tsc": "tsc -p ./tsconfig.xo.json --declaration",
+    "lint": "eslint src/**",
+    "lint:fix": "eslint src/** --fix",
+    "format": "prettier --write src/**"
+  },
+  "lint-staged": {
+    "*.ts": "eslint"
+  },
+  "husky": {
+    "hooks": {
+      "precommit": "npm test && lint-staged && pretty-quick --staged"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/adrian2x/es-next.git"
+  },
+  "keywords": [
+    "es-next",
+    "esnext",
+    "ecmascript",
+    "@esnext",
+    "@es-next",
+    "es6",
+    "es7",
+    "es8",
+    "es2016",
+    "es2017",
+    "es2019",
+    "es2020",
+    "modules",
+    "stdlib",
+    "core-js",
+    "util",
+    "fp"
+  ],
+  "author": "Adrian Cruz <adrian2x>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/adrian2x/es-next/issues"
+  },
+  "homepage": "https://github.com/adrian2x/es-next#readme"
+}