Merge pull request #3415 from abpframework/feat/abp-utils

Created @abp/utils library

npm/packs/utils/.editorconfig

@@ -0,0 +1,16 @@
+# Editor configuration, see https://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.ts]
+quote_type = single
+
+[*.md]
+max_line_length = off
+trim_trailing_whitespace = false

npm/packs/utils/.gitignore

@@ -0,0 +1,50 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+
+# compiled output
+/dist
+/tmp
+/out-tsc
+# Only exists if Bazel was run
+/bazel-out
+/lib
+
+# dependencies
+/node_modules
+
+# profiling files
+chrome-profiler-events*.json
+speed-measure-plugin*.json
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+.history/*
+
+# misc
+/.sass-cache
+/connect.lock
+/coverage
+/libpeerconnection.log
+npm-debug.log
+yarn-error.log
+testem.log
+/typings
+
+# System Files
+.DS_Store
+Thumbs.db
+
+projects/utils/README.md
+projects/utils/package.json

npm/packs/utils/.npmignore

@@ -0,0 +1,2 @@
+**/*
+!dist/**/*

npm/packs/utils/.prettierrc

@@ -0,0 +1,5 @@
+{
+  "singleQuote": true,
+  "printWidth": 100,
+  "trailingComma": "all"
+}

npm/packs/utils/README.md

@@ -0,0 +1 @@
+# @abp/utils

npm/packs/utils/angular.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
+  "version": 1,
+  "newProjectRoot": "projects",
+  "projects": {
+    "utils": {
+      "projectType": "library",
+      "root": "projects/utils",
+      "sourceRoot": "projects/utils/src",
+      "prefix": "lib",
+      "architect": {
+        "build": {
+          "builder": "@angular-devkit/build-ng-packagr:build",
+          "options": {
+            "tsConfig": "projects/utils/tsconfig.lib.json",
+            "project": "projects/utils/ng-package.json"
+          },
+          "configurations": {
+            "production": {
+              "tsConfig": "projects/utils/tsconfig.lib.prod.json"
+            }
+          }
+        },
+        "test": {
+          "builder": "@angular-builders/jest:run",
+          "options": {
+            "coverage": true,
+            "passWithNoTests": true
+          }
+        },
+        "lint": {
+          "builder": "@angular-devkit/build-angular:tslint",
+          "options": {
+            "tsConfig": ["projects/utils/tsconfig.lib.json", "projects/utils/tsconfig.spec.json"],
+            "exclude": ["**/node_modules/**"]
+          }
+        }
+      }
+    }
+  },
+  "cli": {
+    "analytics": false
+  },
+  "defaultProject": "utils"
+}

npm/packs/utils/jest.config.js

@@ -0,0 +1,15 @@
+module.exports = {
+  globals: {
+    'ts-jest': {
+      allowSyntheticDefaultImports: true,
+    },
+  },
+  transform: {
+    '^.+\\.(ts|js|html)$': 'ts-jest',
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '<rootDir>/coverage',
+  coverageReporters: ['html'],
+  preset: 'jest-preset-angular',
+  setupFilesAfterEnv: ['<rootDir>/test-setup.ts'],
+};

npm/packs/utils/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@abp/utils",
+  "version": "2.3.0",
+  "scripts": {
+    "prepublish": "yarn install --ignore-scripts && node prepublish.js",
+    "ng": "ng",
+    "start": "ng serve",
+    "build": "ng build",
+    "test": "ng test",
+    "lint": "ng lint"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/bundles/abp-utils.umd.js",
+  "module": "dist/fesm5/abp-utils.js",
+  "es2015": "dist/fesm2015/abp-utils.js",
+  "esm5": "dist/esm5/abp-utils.js",
+  "esm2015": "dist/esm2015/abp-utils.js",
+  "fesm5": "dist/fesm5/abp-utils.js",
+  "fesm2015": "dist/fesm2015/abp-utils.js",
+  "typings": "dist/abp-utils.d.ts",
+  "metadata": "dist/abp-utils.metadata.json",
+  "sideEffects": false,
+  "devDependencies": {
+    "@angular-builders/jest": "^9.0.0",
+    "@angular-devkit/build-ng-packagr": "~0.901.0",
+    "@angular/cli": "~9.1.0",
+    "@angular/common": "^9.1.0",
+    "@angular/compiler": "~9.1.0",
+    "@angular/compiler-cli": "~9.1.0",
+    "@angular/core": "~9.1.0",
+    "@angular/platform-browser": "^9.1.0",
+    "@angular/platform-browser-dynamic": "^9.1.0",
+    "@types/execa": "^2.0.0",
+    "@types/fs-extra": "^8.1.0",
+    "@types/jest": "^25.1.4",
+    "@types/node": "^12.11.1",
+    "codelyzer": "^5.1.2",
+    "execa": "^4.0.0",
+    "fs-extra": "^9.0.0",
+    "jest": "^25.2.4",
+    "jest-preset-angular": "^8.1.2",
+    "ng-packagr": "^9.0.0",
+    "protractor": "~5.4.3",
+    "ts-node": "~8.3.0",
+    "tslib": "^1.10.0",
+    "tslint": "~6.1.0",
+    "typescript": "~3.6.0",
+    "zone.js": "~0.10.2"
+  },
+  "peerDependencies": {
+    "tslib": "^1.10.0"
+  },
+  "dependencies": {
+    "just-compare": "^1.3.0"
+  }
+}

npm/packs/utils/prepublish.js

@@ -0,0 +1,13 @@
+const fse = require('fs-extra');
+const execa = require('execa');
+
+fse.copyFileSync('./package.json', './projects/utils/package.json');
+fse.copyFileSync('./README.md', './projects/utils/README.md');
+
+try {
+  execa.sync('yarn', ['build'], { stdout: 'inherit' });
+  process.exit(0);
+} catch (error) {
+  console.error(error);
+  process.exit(1);
+}

npm/packs/utils/projects/utils/jest.config.js

@@ -0,0 +1,6 @@
+const jestConfig = require('../../jest.config');
+
+module.exports = {
+  ...jestConfig,
+  name: 'utils',
+};

npm/packs/utils/projects/utils/ng-package.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist",
+  "deleteDestPath": true,
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  },
+  "whitelistedNonPeerDependencies": ["just-compare"]
+}

npm/packs/utils/projects/utils/src/lib/linked-list.ts

@@ -0,0 +1,396 @@
+/* tslint:disable:no-non-null-assertion */
+
+import compare from 'just-compare';
+
+export class ListNode<T = any> {
+  readonly value: T;
+  next: ListNode | undefined;
+  previous: ListNode | undefined;
+
+  constructor(value: T) {
+    this.value = value;
+  }
+}
+
+export class LinkedList<T = any> {
+  private first: ListNode<T> | undefined;
+  private last: ListNode<T> | undefined;
+  private size = 0;
+
+  get head(): ListNode<T> | undefined {
+    return this.first;
+  }
+  get tail(): ListNode<T> | undefined {
+    return this.last;
+  }
+  get length(): number {
+    return this.size;
+  }
+
+  private attach(
+    value: T,
+    previousNode: ListNode<T> | undefined,
+    nextNode: ListNode<T> | undefined,
+  ): ListNode<T> {
+    if (!previousNode) return this.addHead(value);
+
+    if (!nextNode) return this.addTail(value);
+
+    const node = new ListNode(value);
+    node.previous = previousNode;
+    previousNode.next = node;
+    node.next = nextNode;
+    nextNode.previous = node;
+
+    this.size++;
+
+    return node;
+  }
+
+  private attachMany(
+    values: T[],
+    previousNode: ListNode<T> | undefined,
+    nextNode: ListNode<T> | undefined,
+  ): ListNode<T>[] {
+    if (!values.length) return [];
+
+    if (!previousNode) return this.addManyHead(values);
+
+    if (!nextNode) return this.addManyTail(values);
+
+    const list = new LinkedList<T>();
+    list.addManyTail(values);
+    list.first!.previous = previousNode;
+    previousNode.next = list.first;
+    list.last!.next = nextNode;
+    nextNode.previous = list.last;
+
+    this.size += values.length;
+
+    return list.toNodeArray();
+  }
+
+  private detach(node: ListNode<T>) {
+    if (!node.previous) return this.dropHead();
+
+    if (!node.next) return this.dropTail();
+
+    node.previous.next = node.next;
+    node.next.previous = node.previous;
+
+    this.size--;
+
+    return node;
+  }
+
+  add(value: T) {
+    return {
+      after: (previousValue: T, compareFn: ListComparisonFn<T> = compare) =>
+        this.addAfter(value, previousValue, compareFn),
+      before: (nextValue: T, compareFn: ListComparisonFn<T> = compare) =>
+        this.addBefore(value, nextValue, compareFn),
+      byIndex: (position: number) => this.addByIndex(value, position),
+      head: () => this.addHead(value),
+      tail: () => this.addTail(value),
+    };
+  }
+
+  addMany(values: T[]) {
+    return {
+      after: (previousValue: T, compareFn: ListComparisonFn<T> = compare) =>
+        this.addManyAfter(values, previousValue, compareFn),
+      before: (nextValue: T, compareFn: ListComparisonFn<T> = compare) =>
+        this.addManyBefore(values, nextValue, compareFn),
+      byIndex: (position: number) => this.addManyByIndex(values, position),
+      head: () => this.addManyHead(values),
+      tail: () => this.addManyTail(values),
+    };
+  }
+
+  addAfter(value: T, previousValue: T, compareFn: ListComparisonFn<T> = compare): ListNode<T> {
+    const previous = this.find(node => compareFn(node.value, previousValue));
+
+    return previous ? this.attach(value, previous, previous.next) : this.addTail(value);
+  }
+
+  addBefore(value: T, nextValue: T, compareFn: ListComparisonFn<T> = compare): ListNode<T> {
+    const next = this.find(node => compareFn(node.value, nextValue));
+
+    return next ? this.attach(value, next.previous, next) : this.addHead(value);
+  }
+
+  addByIndex(value: T, position: number): ListNode<T> {
+    if (position < 0) position += this.size;
+    else if (position >= this.size) return this.addTail(value);
+
+    if (position <= 0) return this.addHead(value);
+
+    const next = this.get(position)!;
+
+    return this.attach(value, next.previous, next);
+  }
+
+  addHead(value: T): ListNode<T> {
+    const node = new ListNode(value);
+
+    node.next = this.first;
+
+    if (this.first) this.first.previous = node;
+    else this.last = node;
+
+    this.first = node;
+    this.size++;
+
+    return node;
+  }
+
+  addTail(value: T): ListNode<T> {
+    const node = new ListNode(value);
+
+    if (this.first) {
+      node.previous = this.last;
+      this.last!.next = node;
+      this.last = node;
+    } else {
+      this.first = node;
+      this.last = node;
+    }
+
+    this.size++;
+
+    return node;
+  }
+
+  addManyAfter(
+    values: T[],
+    previousValue: T,
+    compareFn: ListComparisonFn<T> = compare,
+  ): ListNode<T>[] {
+    const previous = this.find(node => compareFn(node.value, previousValue));
+
+    return previous ? this.attachMany(values, previous, previous.next) : this.addManyTail(values);
+  }
+
+  addManyBefore(
+    values: T[],
+    nextValue: T,
+    compareFn: ListComparisonFn<T> = compare,
+  ): ListNode<T>[] {
+    const next = this.find(node => compareFn(node.value, nextValue));
+
+    return next ? this.attachMany(values, next.previous, next) : this.addManyHead(values);
+  }
+
+  addManyByIndex(values: T[], position: number): ListNode<T>[] {
+    if (position < 0) position += this.size;
+
+    if (position <= 0) return this.addManyHead(values);
+
+    if (position >= this.size) return this.addManyTail(values);
+
+    const next = this.get(position)!;
+
+    return this.attachMany(values, next.previous, next);
+  }
+
+  addManyHead(values: T[]): ListNode<T>[] {
+    return values.reduceRight<ListNode<T>[]>((nodes, value) => {
+      nodes.unshift(this.addHead(value));
+      return nodes;
+    }, []);
+  }
+
+  addManyTail(values: T[]): ListNode<T>[] {
+    return values.map(value => this.addTail(value));
+  }
+
+  drop() {
+    return {
+      byIndex: (position: number) => this.dropByIndex(position),
+      byValue: (value: T, compareFn: ListComparisonFn<T> = compare) =>
+        this.dropByValue(value, compareFn),
+      byValueAll: (value: T, compareFn: ListComparisonFn<T> = compare) =>
+        this.dropByValueAll(value, compareFn),
+      head: () => this.dropHead(),
+      tail: () => this.dropTail(),
+    };
+  }
+
+  dropMany(count: number) {
+    return {
+      byIndex: (position: number) => this.dropManyByIndex(count, position),
+      head: () => this.dropManyHead(count),
+      tail: () => this.dropManyTail(count),
+    };
+  }
+
+  dropByIndex(position: number): ListNode<T> | undefined {
+    if (position < 0) position += this.size;
+
+    const current = this.get(position);
+
+    return current ? this.detach(current) : undefined;
+  }
+
+  dropByValue(value: T, compareFn: ListComparisonFn<T> = compare): ListNode<T> | undefined {
+    const position = this.findIndex(node => compareFn(node.value, value));
+
+    return position < 0 ? undefined : this.dropByIndex(position);
+  }
+
+  dropByValueAll(value: T, compareFn: ListComparisonFn<T> = compare): ListNode<T>[] {
+    const dropped: ListNode<T>[] = [];
+
+    for (let current = this.first, position = 0; current; position++, current = current.next) {
+      if (compareFn(current.value, value)) {
+        dropped.push(this.dropByIndex(position - dropped.length)!);
+      }
+    }
+
+    return dropped;
+  }
+
+  dropHead(): ListNode<T> | undefined {
+    const head = this.first;
+
+    if (head) {
+      this.first = head.next;
+
+      if (this.first) this.first.previous = undefined;
+      else this.last = undefined;
+
+      this.size--;
+
+      return head;
+    }
+
+    return undefined;
+  }
+
+  dropTail(): ListNode<T> | undefined {
+    const tail = this.last;
+
+    if (tail) {
+      this.last = tail.previous;
+
+      if (this.last) this.last.next = undefined;
+      else this.first = undefined;
+
+      this.size--;
+
+      return tail;
+    }
+
+    return undefined;
+  }
+
+  dropManyByIndex(count: number, position: number): ListNode<T>[] {
+    if (count <= 0) return [];
+
+    if (position < 0) position = Math.max(position + this.size, 0);
+    else if (position >= this.size) return [];
+
+    count = Math.min(count, this.size - position);
+
+    const dropped: ListNode<T>[] = [];
+
+    while (count--) {
+      const current = this.get(position);
+      dropped.push(this.detach(current!)!);
+    }
+
+    return dropped;
+  }
+
+  dropManyHead(count: Exclude<number, 0>): ListNode<T>[] {
+    if (count <= 0) return [];
+
+    count = Math.min(count, this.size);
+
+    const dropped: ListNode<T>[] = [];
+
+    while (count--) dropped.unshift(this.dropHead()!);
+
+    return dropped;
+  }
+
+  dropManyTail(count: Exclude<number, 0>): ListNode<T>[] {
+    if (count <= 0) return [];
+
+    count = Math.min(count, this.size);
+
+    const dropped: ListNode<T>[] = [];
+
+    while (count--) dropped.push(this.dropTail()!);
+
+    return dropped;
+  }
+
+  find(predicate: ListIteratorFn<T>): ListNode<T> | undefined {
+    for (let current = this.first, position = 0; current; position++, current = current.next) {
+      if (predicate(current, position, this)) return current;
+    }
+
+    return undefined;
+  }
+
+  findIndex(predicate: ListIteratorFn<T>): number {
+    for (let current = this.first, position = 0; current; position++, current = current.next) {
+      if (predicate(current, position, this)) return position;
+    }
+
+    return -1;
+  }
+
+  forEach<R = boolean>(callback: ListIteratorFn<T, R>) {
+    for (let node = this.first, position = 0; node; position++, node = node.next) {
+      callback(node, position, this);
+    }
+  }
+
+  get(position: number): ListNode<T> | undefined {
+    return this.find((_, index) => position === index);
+  }
+
+  indexOf(value: T, compareFn: ListComparisonFn<T> = compare): number {
+    return this.findIndex(node => compareFn(node.value, value));
+  }
+
+  toArray(): T[] {
+    const array = new Array(this.size);
+
+    this.forEach((node, index) => (array[index!] = node.value));
+
+    return array;
+  }
+
+  toNodeArray(): ListNode<T>[] {
+    const array = new Array(this.size);
+
+    this.forEach((node, index) => (array[index!] = node));
+
+    return array;
+  }
+
+  toString(mapperFn: ListMapperFn<T> = JSON.stringify): string {
+    return this.toArray()
+      .map(value => mapperFn(value))
+      .join(' <-> ');
+  }
+
+  *[Symbol.iterator](): any {
+    for (let node = this.first, position = 0; node; position++, node = node.next) {
+      yield node.value;
+    }
+  }
+}
+
+export type ListMapperFn<T = any> = (value: T) => any;
+
+export type ListComparisonFn<T = any> = (value1: T, value2: T) => boolean;
+
+export type ListIteratorFn<T = any, R = boolean> = (
+  node: ListNode<T>,
+  index?: number,
+  list?: LinkedList,
+) => R;

npm/packs/utils/projects/utils/src/public-api.ts

@@ -0,0 +1,5 @@
+/*
+ * Public API Surface of utils
+ */
+
+export * from './lib/linked-list';

npm/packs/utils/projects/utils/tsconfig.lib.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "target": "es2015",
+    "declaration": true,
+    "inlineSources": true,
+    "types": [],
+    "lib": ["dom", "es2018"]
+  },
+  "angularCompilerOptions": {
+    "skipTemplateCodegen": true,
+    "strictMetadataEmit": true,
+    "enableResourceInlining": true,
+    "enableIvy": false
+  },
+  "exclude": ["src/test.ts", "**/*.spec.ts"]
+}

npm/packs/utils/projects/utils/tsconfig.spec.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "emitDecoratorMetadata": true,
+    "esModuleInterop": true,
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "include": ["**/*.spec.ts", "**/*.d.ts"]
+}

npm/packs/utils/projects/utils/tslint.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tslint.json",
+  "rules": {
+    "directive-selector": [
+      true,
+      "attribute",
+      "abp",
+      "camelCase"
+    ],
+    "component-selector": [
+      true,
+      "element",
+      "abp",
+      "kebab-case"
+    ]
+  }
+}

npm/packs/utils/test-setup.ts

@@ -0,0 +1 @@
+import 'jest-preset-angular';

npm/packs/utils/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "baseUrl": "./",
+    "outDir": "./dist/out-tsc",
+    "sourceMap": true,
+    "declaration": false,
+    "downlevelIteration": true,
+    "experimentalDecorators": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "importHelpers": true,
+    "target": "es2015",
+    "lib": [
+      "es2018",
+      "dom"
+    ],
+    "paths": {
+      "utils": [
+        "dist/utils/utils",
+        "dist/utils"
+      ]
+    }
+  },
+  "angularCompilerOptions": {
+    "fullTemplateTypeCheck": true,
+    "strictInjectionParameters": true
+  }
+}

npm/packs/utils/tslint.json

@@ -0,0 +1,136 @@
+{
+  "extends": "tslint:recommended",
+  "rulesDirectory": [
+    "codelyzer"
+  ],
+  "rules": {
+    "align": {
+      "options": [
+        "parameters",
+        "statements"
+      ]
+    },
+    "array-type": false,
+    "arrow-return-shorthand": true,
+    "curly": true,
+    "deprecation": {
+      "severity": "warning"
+    },
+    "eofline": true,
+    "import-blacklist": [
+      true,
+      "rxjs/Rx"
+    ],
+    "import-spacing": true,
+    "indent": {
+      "options": [
+        "spaces"
+      ]
+    },
+    "max-classes-per-file": false,
+    "max-line-length": [
+      true,
+      140
+    ],
+    "member-ordering": [
+      true,
+      {
+        "order": [
+          "static-field",
+          "instance-field",
+          "static-method",
+          "instance-method"
+        ]
+      }
+    ],
+    "no-console": [
+      true,
+      "debug",
+      "info",
+      "time",
+      "timeEnd",
+      "trace"
+    ],
+    "no-empty": false,
+    "no-inferrable-types": [
+      true,
+      "ignore-params"
+    ],
+    "no-non-null-assertion": true,
+    "no-redundant-jsdoc": true,
+    "no-switch-case-fall-through": true,
+    "no-var-requires": false,
+    "object-literal-key-quotes": [
+      true,
+      "as-needed"
+    ],
+    "quotemark": [
+      true,
+      "single"
+    ],
+    "semicolon": {
+      "options": [
+        "always"
+      ]
+    },
+    "space-before-function-paren": {
+      "options": {
+        "anonymous": "never",
+        "asyncArrow": "always",
+        "constructor": "never",
+        "method": "never",
+        "named": "never"
+      }
+    },
+    "typedef-whitespace": {
+      "options": [
+        {
+          "call-signature": "nospace",
+          "index-signature": "nospace",
+          "parameter": "nospace",
+          "property-declaration": "nospace",
+          "variable-declaration": "nospace"
+        },
+        {
+          "call-signature": "onespace",
+          "index-signature": "onespace",
+          "parameter": "onespace",
+          "property-declaration": "onespace",
+          "variable-declaration": "onespace"
+        }
+      ]
+    },
+    "variable-name": {
+      "options": [
+        "ban-keywords",
+        "check-format",
+        "allow-pascal-case"
+      ]
+    },
+    "whitespace": {
+      "options": [
+        "check-branch",
+        "check-decl",
+        "check-operator",
+        "check-separator",
+        "check-type",
+        "check-typecast"
+      ]
+    },
+    "component-class-suffix": true,
+    "contextual-lifecycle": true,
+    "directive-class-suffix": true,
+    "no-conflicting-lifecycle": true,
+    "no-host-metadata-property": true,
+    "no-input-rename": true,
+    "no-inputs-metadata-property": true,
+    "no-output-native": true,
+    "no-output-on-prefix": true,
+    "no-output-rename": true,
+    "no-outputs-metadata-property": true,
+    "template-banana-in-box": true,
+    "template-no-negated-async": true,
+    "use-lifecycle-interface": true,
+    "use-pipe-transform-interface": true
+  }
+}