ngx-axis-appforge 0.0.0

package/core/utils/object.utils.ts

@@ -0,0 +1,182 @@
+export function listSort(list: Array<any>, compareField: string, reverse: boolean = false) {
+  const type = typeof list.map(e => e[compareField]).find(e => e != null);
+  const factor = reverse ? -1 : 1;
+  if (type == "number") {
+    list.sort((a, b) => (a[compareField] - b[compareField]) * factor);
+  } else if (type == "string") {
+    list.sort((a, b) => ((a[compareField] || "") + "").localeCompare(b[compareField]) * factor);
+  }
+}
+
+export function trackByFn(trackByField: string) {
+  return (index: number, item: any) => {
+    return item[trackByField];
+  }
+}
+
+export function copy(obj: any, deepCopy = false) {
+  let newobj = obj;
+  if (obj instanceof Array) {
+    newobj = [];
+    obj.forEach((item, i) => {
+      try {
+        newobj[i] = copy(item, deepCopy);
+      } catch (e) {
+        console.error("复制对象失败", obj);
+      }
+    });
+  } else if (obj instanceof Object) {
+    newobj = Object.assign({}, obj);
+    if (deepCopy) {
+      for (const n in newobj) {
+        if (newobj[n] instanceof Object) {
+          newobj[n] = copy(newobj[n], deepCopy);
+        }
+      }
+    }
+  }
+  return newobj;
+}
+
+export function deepMerge(...objs: any[]) {
+  const temp: any = {};
+  objs = objs.filter(e => e);
+  objs.forEach(o => {
+    Object.keys(o).filter(k => o[k] != null && typeof o[k] == "object" && !(o[k] instanceof Array)).forEach(k => {
+      if (!temp.hasOwnProperty(k)) {
+        temp[k] = {};
+      }
+      temp[k] = deepMerge(temp[k], o[k]);
+    });
+  });
+  objs.push(temp);
+  return Object.assign({}, ...objs);
+}
+
+export function obj2Arr(obj: any) {
+  const arr = [];
+  if (obj) {
+    for (let n in obj) {
+      arr.push(obj[n]);
+    }
+  }
+  return arr;
+}
+
+export function recursionArray(arr: any[], options: { childrenField?: string, before?: (node: any, level: number, parent?: any) => boolean | void, after?: (node: any, level: number, parent?: any) => boolean | void }, offsetLevel = 0, parent?: any): boolean | void {
+  const childrenField = options.childrenField ?? "children";
+  if (options.before || options.after) {
+    for (let i = 0; i < arr.length; i++) {
+      const n = arr[i];
+      let ctn = options.before?.(n, offsetLevel, parent);
+      if (ctn === false) {
+        return;
+      }
+      if (Array.isArray(n[childrenField])) {
+        if (recursionArray(n[childrenField], options, offsetLevel + 1, n) === false) {
+          return false;
+        }
+      }
+      ctn = options.after?.(n, offsetLevel, parent);
+      if (ctn === false) {
+        return;
+      }
+    }
+  }
+}
+
+export function recursionObject(obj: any, handler: (keys: string[], value: any, parent: any) => void, keys: string[] = [], parent?: any) {
+  if (!obj) {
+    handler(keys, obj, parent);
+  } else if (obj instanceof Array) {
+    obj.forEach((v, i) => {
+      const nextKeys: string[] = ([] as string[]).concat(keys);
+      nextKeys.push(i.toString());
+      recursionObject(v, handler, nextKeys, obj);
+    });
+  } else if (typeof (obj) == "object") {
+    Object.keys(obj).forEach(k => {
+      const nextKeys: string[] = ([] as string[]).concat(keys);
+      nextKeys.push(k);
+      recursionObject(obj[k], handler, nextKeys, obj);
+    });
+  } else {
+    handler(keys, obj, parent);
+  }
+}
+
+export function rebuildObject(targetObj: any, sourceObj: any) {
+  if (sourceObj) {
+    if (!targetObj) {
+      targetObj = {};
+    }
+    Object.keys(targetObj).forEach(k => {
+      delete targetObj[k];
+    });
+    Object.assign(targetObj, sourceObj);
+  }
+  return targetObj;
+}
+
+export function assignDefaultField(targetObj: any, sourceObj: any) {
+  if (!targetObj) {
+    return sourceObj;
+  } else if (!sourceObj) {
+    return targetObj;
+  } else {
+    Object.keys(sourceObj).forEach(k => {
+      if (targetObj[k] == undefined) {
+        targetObj[k] = sourceObj[k];
+      }
+    });
+    return targetObj;
+  }
+}
+
+export function isEquals(objA: any, objB: any): boolean {
+  if (objA !== objB) {
+    const t = typeof (objA);
+    if (t != typeof (objB)) {
+      return false;
+    }
+    switch (t) {
+      case "object":
+        if (!objA && !objB) {
+          return false;
+        } else if (objA && objB) {
+          const keysA = Object.keys(objA);
+          const keysB = Object.keys(objB);
+          if (keysA.length != keysB.length) {
+            return false;
+          }
+          for (const k of keysA) {
+            if (!isEquals(objA[k], objB[k])) {
+              return false;
+            }
+          }
+        } else {
+          return false;
+        }
+        break;
+      default:
+        return objA == objB;
+    }
+  }
+  return true;
+}
+
+export function objDiff(last: { [k: string]: any } | undefined | null, current: { [k: string]: any } | undefined | null): Set<string> {
+  const diff = new Set<string>();
+  if (last && current) {
+    for (const key of new Set(Object.keys(last).concat(Object.keys(current)))) {
+      if (last[key] != current[key]) {
+        diff.add(key);
+      }
+    }
+  } else if (last) {
+    return new Set(Object.keys(last));
+  } else if (current) {
+    return new Set(Object.keys(current));
+  }
+  return diff;
+}

package/core/utils/scripts-loader.ts

@@ -0,0 +1,25 @@
+const loadedMap = new Map<string, any>();
+const loadingMap = new Map<string, Promise<any>>();
+
+export function loadScripts(path: string): Promise<string> {
+    if (loadedMap.has(path)) {
+        return Promise.resolve(loadedMap.get(path)!);
+    }
+    if (loadingMap.has(path)) {
+        return loadingMap.get(path)!;
+    }
+    loadingMap.set(path, downloadScript(path).then(script => {
+        loadedMap.set(path, script);
+        loadingMap.delete(path);
+        return script;
+    }));
+    return loadingMap.get(path)!;
+}
+
+export function syncLoadScript(path: string): string | undefined {
+    return loadedMap.get(path);
+}
+
+async function downloadScript(path: string): Promise<any> {
+    return await (await fetch(path)).text();
+}

package/ng-package.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "./node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "./dist/ngx-axis-appforge",
+  "lib": {
+    "entryFile": "public-api.ts"
+  },
+  "allowedNonPeerDependencies": [
+    "ngx-axis-appforge"
+  ],
+  "assets": [
+    "axis-components-covers/*"
+  ]
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "ngx-axis-appforge",
+  "version": "0.0.0",
+  "author": "ZengCheng <zengc694623467@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@angular/common": "^20.1.2",
+    "@angular/compiler": "^20.1.2",
+    "@angular/core": "^20.1.2",
+    "@angular/forms": "^20.1.2",
+    "@angular/platform-browser": "^20.1.2",
+    "@angular/router": "^20.1.2",
+    "monaco-editor": "^0.52.2",
+    "ng-zorro-antd": "^20.1.0",
+    "ngx-axis-appforge": "file:./dist/ngx-axis-appforge/",
+    "ngx-clipboard": "^16.0.0",
+    "rxjs": "~7.8.0",
+    "zone.js": "~0.15.0"
+  },
+  "devDependencies": {
+    "@angular/build": "^20.1.1",
+    "@angular/cli": "^20.1.1",
+    "@angular/compiler-cli": "^20.1.2",
+    "@types/jasmine": "~5.1.0",
+    "jasmine-core": "~5.7.0",
+    "karma": "~6.4.0",
+    "karma-chrome-launcher": "~3.2.0",
+    "karma-coverage": "~2.2.0",
+    "karma-jasmine": "~5.1.0",
+    "karma-jasmine-html-reporter": "~2.1.0",
+    "ng-packagr": "^20.0.0",
+    "typescript": "~5.8.2"
+  }
+}

package/providers/ng-package.json

@@ -0,0 +1,5 @@
+{
+    "lib": {
+        "entryFile": "public-api.ts"
+    }
+}

package/providers/providers.ts

@@ -0,0 +1,44 @@
+import { inject, Provider, Type } from "@angular/core";
+import { AXIS_COMPONENTS_LOADER_TOKEN, AXIS_COMPONENTS_TOKEN, AXIS_DESIGN_CMPLIBS_TOKEN, AXIS_EVENT_HANDLER_DESCS_TOKEN, AXIS_EVENT_HANDLERS_TOKEN, AXIS_SCRIPTS_TOKEN, Cmplib, ComponentsLoader, EventHandlerDescGroup, EventsHandler } from "ngx-axis-appforge/core";
+export function provideAxisAppforge(config?: { cmplibs?: Cmplib[], scripts?: { [name: string]: string }, eventHandlers?: (EventsHandler | Type<EventsHandler>)[], eventHandlerDescs?: EventHandlerDescGroup[] }): Provider {
+    return [
+        {
+            provide: AXIS_COMPONENTS_TOKEN,
+            useValue: config?.cmplibs?.map(lib => lib.cmpMap)?.reduce((a, b) => ({ ...a, ...b }), {})
+        },
+        {
+            provide: AXIS_SCRIPTS_TOKEN,
+            useValue: config?.scripts,
+        },
+        {
+            provide: AXIS_DESIGN_CMPLIBS_TOKEN,
+            useValue: config?.cmplibs?.map(lib => ({ libName: lib.name, lib: lib.examples })),
+        },
+        {
+            provide: AXIS_COMPONENTS_LOADER_TOKEN,
+            useClass: ComponentsLoader,
+        },
+        {
+            provide: AXIS_EVENT_HANDLERS_TOKEN,
+            useFactory: () => {
+                let eventHandlers: EventsHandler[] | undefined;
+                if (config?.eventHandlers) {
+                    eventHandlers = [];
+                    for (let e of config.eventHandlers) {
+                        if (e instanceof Type) {
+                            eventHandlers.push(inject(e));
+                        } else {
+                            eventHandlers.push(e);
+                        }
+                    }
+                }
+                return eventHandlers;
+            },
+
+        },
+        {
+            provide: AXIS_EVENT_HANDLER_DESCS_TOKEN,
+            useValue: config?.eventHandlerDescs,
+        }
+    ]
+}

package/providers/public-api.ts

@@ -0,0 +1 @@
+export * from './providers'

package/public-api.ts

@@ -0,0 +1 @@
+export default void 0;

package/tsconfig.json

@@ -0,0 +1,38 @@
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "baseUrl": ".",
+    "rootDir": ".",
+    "paths": {
+      "@ngx-axis-appforge/core": [
+        "./core"
+      ]
+    },
+    "noFallthroughCasesInSwitch": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "experimentalDecorators": true,
+    "importHelpers": true,
+    "target": "ES2022",
+    "module": "preserve"
+  },
+  "angularCompilerOptions": {
+    "enableI18nLegacyMessageIdFormat": false,
+    "strictInjectionParameters": true,
+    "strictInputAccessModifiers": true,
+    "typeCheckHostBindings": true,
+    "strictTemplates": true
+  },
+  "files": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ],
+}

package/tsconfig.lib.json

@@ -0,0 +1,19 @@
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./out-tsc",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "sourceMap": true, 
+    "types": []
+  },
+  "include": [
+    "**/*.ts"
+  ],
+  "exclude": [
+    "**/*.spec.ts"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,11 @@
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}