Initial import from old repo.

Author: blendsdk

.gitignore

@@ -59,3 +59,5 @@ typings/
 
 # next.js build output
 .next
+
+dist

.npmignore

@@ -0,0 +1,10 @@
+src
+jest.config.js
+tsconfig.json
+tslint.json
+jsconfig.json
+.gitignore
+node_modules
+dist/tests
+fiddle.ts
+*.tgz

README.md

@@ -0,0 +1,27 @@
+# Git
+
+Common library and utilities to use Git in NodeJS
+
+## Installation
+
+```typescript
+yarn add @blendsdk/git --save
+```
+
+```typescript
+npm install @blendsdk/git --save
+```
+
+# Utlities
+
+Check if we are on a given branch
+
+```bash
+is_git_branch <branch name>
+```
+
+Check if the current working git folder is clean
+
+```bash
+is_git_clean
+```

jest.config.js

@@ -0,0 +1,13 @@
+module.exports = {
+    globals: {
+        "ts-jest": {
+            tsConfig: "tsconfig.json"
+        }
+    },
+    moduleFileExtensions: ["ts", "js"],
+    transform: {
+        "^.+\\.(ts|tsx)$": "ts-jest"
+    },
+    testMatch: ["**/tests/**/*.spec.(ts)"],
+    testEnvironment: "node"
+};

jsconfig.json

@@ -0,0 +1,5 @@
+{
+    "typeAcquisition": {
+        "include": ["jest"]
+    }
+}

package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@blendsdk/git",
+  "version": "0.9.4",
+  "description": "Standard utility functions to be used in TypeScript",
+  "main": "dist/index.js",
+  "author": "Gevik Babakhani <[email protected]>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/blendsdk/stdlib.git"
+  },
+  "keywords": [
+    "typescript",
+    "utility",
+    "language"
+  ],
+  "license": "MIT",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "rm -fR ./dist && tsc",
+    "watch": "rm -fR ./dist && tsc -w ",
+    "fiddle": "node ./dist/fiddle.js",
+    "test": "jest --detectOpenHandles",
+    "patch-publish": "node ./dist/utils/is_git_clean && node ./dist/utils/is_git_branch master && yarn build && yarn publish --patch --access public && git push origin master --tags"
+  },
+  "dependencies": {
+    "tslib": "^1.10.0"
+  },
+  "devDependencies": {
+    "@blendsdk/git": "^0.9.4",
+    "@types/jest": "^24.0.15",
+    "@types/node": "^12.0.12",
+    "jest": "^24.8.0",
+    "ts-jest": "^24.0.2",
+    "typescript": "^3.5.2"
+  }
+}

src/ID.ts

@@ -0,0 +1,14 @@
+let _ID: number = 1000;
+
+/**
+ * Generates a new identifier.
+ *
+ * @export
+ * @returns {number}
+ */
+export function ID(): number {
+    return (a => {
+        const r = a;
+        return r;
+    })(_ID++);
+}

src/apply.ts

@@ -0,0 +1,53 @@
+import { isNullOrUndef } from "./isNullOrUndef";
+
+import { isArray, isObject } from "util";
+
+import { wrapInArray } from "./wrapInArray";
+
+/**
+ * Copies keys and values from one object to another.
+ * This function can optionally merge arrays and overwrite objects
+ * in the target parameters from the source parameter.
+ *
+ * @export
+ * @param {*} target
+ * @param {*} source
+ * @param {{ overwrite?: boolean, mergeArrays?: boolean }} [options]
+ * @returns {*}
+ */
+export function apply<T>(target: any, source: any, options?: { overwrite?: boolean; mergeArrays?: boolean }): any {
+    let key: any;
+    const targetKeys = Object.keys(target || {}),
+        targetHasKey = (k: string): boolean => {
+            return targetKeys.indexOf(k) !== -1;
+        };
+    options = options || {
+        mergeArrays: false,
+        overwrite: false
+    };
+
+    if (!isNullOrUndef(target) && !isNullOrUndef(source)) {
+        if (isArray(target) && !isArray(source)) {
+            target.push(source);
+        } else {
+            for (key in source) {
+                if (key && source.hasOwnProperty(key)) {
+                    if (targetHasKey(key) && isObject(target[key])) {
+                        if (options.overwrite === true) {
+                            target[key] = source[key];
+                        } else {
+                            apply(target[key], source[key]);
+                        }
+                    } else if (targetHasKey(key) && isArray(target[key]) && options.mergeArrays === true) {
+                        target[key] = target[key].concat(wrapInArray(source[key]));
+                    } else if (targetHasKey(key) && options.overwrite === true) {
+                        target[key] = source[key];
+                    } else if (isNullOrUndef(target[key])) {
+                        target[key] = source[key];
+                    }
+                }
+            }
+        }
+    }
+    return target as T;
+}

src/argumentsToArray.ts

@@ -0,0 +1,16 @@
+import { forEach } from "./forEach";
+
+/**
+ * Converts the function arguments to an array.
+ *
+ * @export
+ * @param {IArguments} args
+ * @returns {Array<any>}
+ */
+export function argumentsToArray(args: IArguments): any[] {
+    const result: any[] = [];
+    forEach(args, (item: any) => {
+        result.push(item);
+    });
+    return result;
+}

src/dashedCase.ts

@@ -0,0 +1,11 @@
+/**
+ * Converts a camelCase string to dashed case.
+ * For example backgroundColor will be background-color
+ *
+ * @export
+ * @param {string} value
+ * @returns {string}
+ */
+export function dashedCase(value: string): string {
+    return value.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}

src/debounce.ts

@@ -0,0 +1,38 @@
+import { TFunction } from "./types";
+
+/**
+ * Returns a function, that, as long as it continues to be invoked, will not
+ * be triggered. The function will be called after it stops being called for
+ * `delay` number of milliseconds. If `immediate` is passed, trigger the function
+ * on the leading edge, instead of the trailing.
+ *
+ * @copyright This function ir originally ported from the underscore.js library and it copyrighted in MIT
+ * @export
+ * @param {number} delay
+ * @param {Function} callback
+ * @param {*} scope
+ * @param {boolean} immediate
+ * @returns {Function}
+ */
+// tslint:disable-next-line:no-shadowed-variable
+export function debounce(delay: number, callback: TFunction, scope?: any, immediate?: boolean): TFunction {
+    let timeout: any;
+    immediate = immediate || false;
+    return function () {
+        const me = this;
+        scope = scope || me;
+        const args = arguments;
+        const later = () => {
+            timeout = null;
+            if (!immediate) {
+                callback.apply(scope, args);
+            }
+        },
+            callNow = immediate && !timeout;
+        clearTimeout(timeout);
+        timeout = setTimeout(later, delay);
+        if (callNow) {
+            callback.apply(scope, args);
+        }
+    };
+}

src/delay.ts

@@ -0,0 +1,17 @@
+import { TFunction } from "./types";
+
+/**
+ * Runs the given callback after given milliseconds.
+ * This function is a wrapper around setTimeout
+ *
+ * @export
+ * @param {number} ms
+ * @param {Function} callback
+ * @param {*} [scope]
+ */
+export function delay(ms: number, callback: TFunction, scope?: any) {
+    scope = scope || window;
+    setTimeout(() => {
+        callback.apply(scope, []);
+    }, ms);
+}

src/ensureBoolean.ts

@@ -0,0 +1,10 @@
+/**
+ * Ensures that the given value is a boolean
+ *
+ * @export
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function ensureBoolean(value: any): boolean {
+    return value === true ? true : false;
+}

src/forEach.ts

@@ -0,0 +1,59 @@
+import { isInstanceOf } from "./isInstanceOf";
+import { isFunction } from "./isFunction";
+import { isArray } from "./isArray";
+
+/**
+ * Loops though the given object (array, dictionary, NodeList, HTMLCollection) and runs
+ * a callback on each item.
+ * The callback loop will break when the callback function returns "false" explicitly!
+ *
+ * @export
+ * @template T
+ * @param {*} obj
+ * @param {((item: T, index: number | string, scope: any) => any | boolean)} callback
+ * @param {*} [scope]
+ * @returns
+ */
+export function forEach<T>(
+    obj: any,
+    callback: (item: T, index: number | string, scope: any) => any | boolean,
+    scope?: any
+) {
+    let key: any;
+    const isHTMLCollection = (elObj: any): boolean => {
+        return (
+            (elObj.constructor && elObj.constructor.name && elObj.constructor.name === "HTMLCollection") ||
+            elObj.toString() === "[object HTMLCollection]"
+        );
+    };
+    if (obj) {
+        if (isFunction(obj)) {
+            return;
+        } else if (isArray(obj)) {
+            // tslint:disable-next-line:no-shadowed-variable
+            const length: number = obj.length;
+            for (key = 0; key < length; key++) {
+                if (callback.call(scope, obj[key], key, obj) === false) {
+                    break;
+                }
+            }
+        } else if (isHTMLCollection(obj) || isInstanceOf(obj, NodeList)) {
+            const length: number = obj.length;
+            let el: HTMLElement;
+            for (key = 0; key !== length; key++) {
+                el = obj.item(key);
+                if (callback.call(scope, el, key, obj) === false) {
+                    break;
+                }
+            }
+        } else {
+            for (key in obj) {
+                if (obj.hasOwnProperty(key)) {
+                    if (callback.call(scope, obj[key], key, obj) === false) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+}

src/index.ts

@@ -0,0 +1,23 @@
+export * from "./apply";
+export * from "./argumentsToArray";
+export * from "./dashedCase";
+export * from "./debounce";
+export * from "./delay";
+export * from "./ensureBoolean";
+export * from "./forEach";
+export * from "./ID";
+export * from "./isArray";
+export * from "./isBoolean";
+export * from "./isClass";
+export * from "./isDate";
+export * from "./isFunction";
+export * from "./isInstanceOf";
+export * from "./isNullOrUndef";
+export * from "./isNumeric";
+export * from "./isObject";
+export * from "./isRegExp";
+export * from "./isString";
+export * from "./random";
+export * from "./shallowClone";
+export * from "./types";
+export * from "./wrapInArray";

src/isArray.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests whether the given value is an array.
+ *
+ * @export
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function isArray(value: any): boolean {
+    return Object.prototype.toString.apply(value) === "[object Array]";
+}

src/isBoolean.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests whether the given value is a boolean.
+ *
+ * @export
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function isBoolean(value: any): boolean {
+    return typeof value === "boolean";
+}