@ibiz-template/runtime 0.7.41-alpha.104 → 0.7.41-alpha.106

package/src/utils/html2canvas/html2canvas.ts

@@ -0,0 +1,43 @@
+import html2canvas from 'html2canvas';
+import { IApiHtml2canvasUtil, IHtml2canvasOption } from '../../interface';
+
+/**
+ * @description Html2Canvas工具类
+ * @export
+ * @class Html2Canvas
+ */
+export class Html2Canvas implements IApiHtml2canvasUtil {
+  /**
+   * @description 导出canvas
+   * @param {HTMLElement} dom
+   * @param {IHtml2canvasOption} [option={}]
+   * @returns {*}  {Promise<void>}
+   * @memberof Html2Canvas
+   */
+  async exportCanvas(
+    dom: HTMLElement,
+    option: IHtml2canvasOption = {},
+  ): Promise<void> {
+    const canvas = await html2canvas(dom, option);
+    const dataURL = canvas.toDataURL('image/png');
+    const link = document.createElement('a');
+    link.href = dataURL;
+    const fileName = option.fileName || '导出图片';
+    link.download = `${fileName}.png`;
+    link.click();
+  }
+
+  /**
+   * @description 获取canvas元素
+   * @param {HTMLElement} dom
+   * @param {IHtml2canvasOption} [option={}]
+   * @returns {*}  {Promise<HTMLCanvasElement>}
+   * @memberof Html2Canvas
+   */
+  async getCanvas(
+    dom: HTMLElement,
+    option: IHtml2canvasOption = {},
+  ): Promise<HTMLCanvasElement> {
+    return html2canvas(dom, option);
+  }
+}

package/src/utils/html2canvas/index.ts

@@ -0,0 +1 @@
+export { Html2Canvas } from './html2canvas';

package/src/utils/index.ts

@@ -0,0 +1,44 @@
+export * from './error-handler';
+export { HandlebarsUtil } from './handlebars/handlebars';
+export { calcNavParams } from './nav-params/calc-nav-params';
+export * from './nav-params/nav-params';
+export {
+  toLocalOpenWFRedirectView,
+  openRedirectView,
+  getDERedirectToView,
+  parseViewProtocol,
+} from './open-redirect-view/open-redirect-view';
+export * from './verify';
+export { LayoutPanelUtil } from './layout-panel-util/layout-panel-util';
+export * from './wf-helper/wf-helper';
+export * from './modal/modal';
+export * from './value-rule/value-rule';
+export * from './script/index';
+export { TextUtil } from './text-util/text-util';
+export { ThemeUtil } from './theme-util/theme-util';
+export { UIDomain } from './ui-domain/ui-domain';
+export { UIDomainManager } from './ui-domain-manager/ui-domain-manager';
+export { RawValueUtil } from './raw-value-util/raw-value-util';
+export { ViewStack } from './view-stack/view-stack';
+export { handleAllSettled } from './promise/promise';
+export { AnimeUtil } from './anime';
+export { FileUtil } from './file-util';
+export { ShortCutUtil } from './short-cut/short-cut-util';
+export { BIReportUtil } from './bi-report-util/bi-report-util';
+export { RecordNavUtil } from './record-nav-util/record-nav-util';
+export { JsonSchemaUtil } from './jsonschema-util/jsonschema-util';
+export { CollaborateRoom } from './collaborate-room/collaborate-room';
+export { CollaborateManager } from './collaborate-manager/collaborate-manager';
+export { Html2Canvas } from './html2canvas/html2canvas';
+export { VoiceUtil } from './voice-util/voice-util';
+export { EncyptionUtil } from './encryption-uitl/encryption-uitl';
+export * from './dr-ctrl-util';
+export * from './date-util';
+export { ChangeTracker } from './change-tracker/change-tracker';
+export { ViewShellHooks } from './view-shell-hooks/view-shell-hooks';
+export { WaterMarkUtil } from './water-mark-util/water-mark-util';
+export * from './map-util/map-util';
+export * from './wechat-util/wechat-util';
+export * from './json-util/json-util';
+export * from './stringify-util/stringify-util';
+export * from './model';

package/src/utils/json-util/JsonContext.ts

@@ -0,0 +1,43 @@
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class JsonContext {
+  contextStack: any[];
+
+  constructor() {
+    this.contextStack = [];
+  }
+
+  get current() {
+    return this.contextStack[this.contextStack.length - 1];
+  }
+
+  get context() {
+    return [...this.contextStack];
+  }
+
+  get empty() {
+    return this.contextStack.length === 0;
+  }
+
+  set(value: any) {
+    this.contextStack.push(value);
+  }
+
+  reset() {
+    this.contextStack = [];
+  }
+
+  remove(value: any) {
+    const index = this.contextStack.lastIndexOf(value);
+    if (index !== -1) {
+      this.contextStack.splice(index, 1);
+    }
+  }
+}
+
+export const ContextValues = {
+  OBJECT_KEY: 'OBJECT_KEY',
+  OBJECT_VALUE: 'OBJECT_VALUE',
+  ARRAY: 'ARRAY',
+};

package/src/utils/json-util/JsonParser.ts

@@ -0,0 +1,296 @@
+/* eslint-disable no-restricted-globals */
+/* eslint-disable no-plusplus */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ContextValues, JsonContext } from './JsonContext';
+
+const STRING_DELIMITERS = ['"', "'"];
+const WHITESPACE = new Set([0x20, 0x09, 0x0a, 0x0d]); // space, tab, newline, return
+
+export class JsonParser {
+  jsonStr: string;
+
+  index: number;
+
+  context: JsonContext;
+
+  logging: boolean;
+
+  logger: any[];
+
+  constructor(jsonStr = '', logging = false) {
+    this.jsonStr = jsonStr;
+    this.index = 0;
+    this.context = new JsonContext();
+    this.logging = logging;
+    this.logger = [];
+  }
+
+  log(text: string) {
+    if (!this.logging) return;
+    const window = 10;
+    const start = Math.max(this.index - window, 0);
+    const end = Math.min(this.index + window, this.jsonStr.length);
+    const context = this.jsonStr.slice(start, end);
+    this.logger.push({ text, context });
+  }
+
+  parse() {
+    // Find the first { or [ in the string
+    let inBackticks = false;
+    let foundJson = false;
+
+    while (this.index < this.jsonStr.length) {
+      const char = this.peek();
+
+      // Handle code blocks in markdown/text
+      if (char === '`') {
+        if (this.jsonStr.slice(this.index, this.index + 3) === '```') {
+          inBackticks = !inBackticks;
+          this.index += 3;
+          continue;
+        }
+      }
+
+      // Look for JSON start
+      if (char === '{' || char === '[') {
+        foundJson = true;
+        break;
+      }
+
+      this.index++;
+    }
+
+    if (!foundJson) {
+      return '';
+    }
+
+    const result = this.parseValue();
+    return this.logging ? [result, this.logger] : result;
+  }
+
+  parseValue(): any {
+    this.skipWhitespace();
+    const char = this.peek();
+
+    if (!char) return '';
+
+    if (char === '{') return this.parseObject();
+    if (char === '[') return this.parseArray();
+    if (STRING_DELIMITERS.includes(char)) return this.parseString();
+    if (/[-0-9]/.test(char)) return this.parseNumber();
+    if (/[a-zA-Z]/.test(char)) return this.parseUnquotedString();
+
+    this.index++;
+    return '';
+  }
+
+  parseObject() {
+    const obj: any = {};
+    this.index++; // skip {
+
+    while (this.index < this.jsonStr.length) {
+      this.skipWhitespace();
+
+      if (this.peek() === '}') {
+        this.index++;
+        break;
+      }
+
+      // Parse key
+      this.context.set(ContextValues.OBJECT_KEY);
+      const key: any = this.parseString() || this.parseUnquotedString();
+      if (!key) break;
+
+      this.skipWhitespace();
+
+      // Handle missing colon
+      if (this.peek() !== ':') {
+        this.log('Missing colon after key, adding it');
+      } else {
+        this.index++; // skip :
+      }
+
+      this.skipWhitespace();
+
+      // Parse value
+      this.context.reset();
+      this.context.set(ContextValues.OBJECT_VALUE);
+      const value = this.parseValue();
+      this.context.reset();
+
+      if (key) {
+        obj[key] = value;
+      }
+
+      this.skipWhitespace();
+
+      // Handle comma
+      if (this.peek() === ',') {
+        this.index++;
+      }
+    }
+
+    return obj;
+  }
+
+  parseArray() {
+    const arr = [];
+    this.index++; // skip [
+    this.context.set(ContextValues.ARRAY);
+
+    while (this.index < this.jsonStr.length) {
+      this.skipWhitespace();
+
+      if (this.peek() === ']') {
+        this.index++;
+        break;
+      }
+
+      const value = this.parseValue();
+      if (value !== undefined) {
+        arr.push(value);
+      }
+
+      this.skipWhitespace();
+
+      // Handle comma
+      if (this.peek() === ',') {
+        this.index++;
+      }
+    }
+
+    this.context.reset();
+    return arr;
+  }
+
+  parseString() {
+    let char = this.peek();
+    const isQuoted = STRING_DELIMITERS.includes(char);
+    let stringAcc = '';
+
+    // Skip leading whitespace
+    while (char && /\s/.test(char)) {
+      this.index++;
+      char = this.peek();
+    }
+
+    if (isQuoted) {
+      const quote = char;
+      this.index++; // skip opening quote
+
+      while (this.index < this.jsonStr.length) {
+        char = this.peek();
+
+        if (char === quote && this.jsonStr[this.index - 1] !== '\\') {
+          this.index++; // skip closing quote
+          break;
+        }
+        // fix: 修复字符串拼接\n、\r、\t、\\特殊字符语义丢失问题
+        if (char === '\\') {
+          const next = this.jsonStr[this.index + 1];
+          switch (next) {
+            case 'n':
+              stringAcc += '\n';
+              this.index += 2; // 跳过 \ 和 n
+              continue;
+            case 'r':
+              stringAcc += '\r';
+              this.index += 2;
+              continue;
+            case 't':
+              stringAcc += '\t';
+              this.index += 2;
+              continue;
+            case '\\':
+              stringAcc += '\\';
+              this.index += 2;
+              continue;
+            default:
+              stringAcc += char;
+          }
+        } else {
+          stringAcc += char;
+        }
+        this.index++;
+      }
+    } else {
+      // For unquoted strings, collect until delimiter
+      while (this.index < this.jsonStr.length) {
+        char = this.peek();
+
+        if ([',', '}', ']', ':'].includes(char)) {
+          break;
+        } else if (/\s/.test(char)) {
+          // Skip whitespace between words
+          if (stringAcc && this.index < this.jsonStr.length - 1) {
+            const nextChar = this.jsonStr[this.index + 1];
+            if (!/[,}\]:]/.test(nextChar)) {
+              stringAcc += ' ';
+            }
+          }
+        } else {
+          stringAcc += char;
+        }
+
+        this.index++;
+      }
+    }
+
+    // Convert value types for object values
+    if (!isQuoted && this.context.current === ContextValues.OBJECT_VALUE) {
+      const trimmed = stringAcc.trim();
+
+      // Try number
+      const num = Number(trimmed);
+      if (!isNaN(num)) return num;
+
+      // Try boolean/null
+      if (trimmed.toLowerCase() === 'true') return true;
+      if (trimmed.toLowerCase() === 'false') return false;
+      if (trimmed.toLowerCase() === 'null') return null;
+    }
+
+    return stringAcc.trim();
+  }
+
+  parseNumber() {
+    let numStr = '';
+
+    while (this.index < this.jsonStr.length) {
+      const char = this.peek();
+      if (!/[-0-9.eE]/.test(char)) break;
+      numStr += char;
+      this.index++;
+    }
+
+    const num = Number(numStr);
+    return isNaN(num) ? numStr : num;
+  }
+
+  parseUnquotedString() {
+    let str = '';
+
+    while (this.index < this.jsonStr.length) {
+      const char = this.peek();
+      if ([',', '}', ']', ':'].includes(char) || /\s/.test(char)) break;
+      str += char;
+      this.index++;
+    }
+
+    return str;
+  }
+
+  skipWhitespace() {
+    while (this.index < this.jsonStr.length) {
+      const code = this.jsonStr.charCodeAt(this.index);
+      if (!WHITESPACE.has(code)) break;
+      this.index++;
+    }
+  }
+
+  peek() {
+    return this.jsonStr[this.index];
+  }
+}

package/src/utils/json-util/json-repair.ts

@@ -0,0 +1,75 @@
+/* eslint-disable no-control-regex */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+
+import { JsonParser } from './JsonParser';
+
+/**
+ * Bozuk JSON string'ini onarır
+ * @param {string} jsonStr - Onarılacak JSON string'i
+ * @param {Object} options - Onarım seçenekleri
+ * @param {boolean} options.returnObjects - true ise JavaScript objesi döner, false ise JSON string döner
+ * @param {boolean} options.skipJsonParse - true ise JSON.parse kontrolünü atlar
+ * @param {boolean} options.logging - true ise onarım loglarını da döner
+ * @param {boolean} options.ensureAscii - false ise Unicode karakterleri korur
+ * @returns {string|Object} Onarılmış JSON string'i veya objesi
+ */
+export function repairJson(jsonStr = '', options: any = {}) {
+  const {
+    returnObjects = false,
+    skipJsonParse = false,
+    logging = false,
+    ensureAscii = true,
+  } = options;
+
+  // Önce normal JSON.parse ile dene
+  if (!skipJsonParse) {
+    try {
+      const parsed = JSON.parse(jsonStr);
+      return returnObjects ? parsed : JSON.stringify(parsed, null, 2);
+    } catch (e) {
+      // JSON.parse başarısız olursa devam et
+    }
+  }
+
+  // JSON.parse başarısız olduysa veya atlanması istendiyse, onararak parse et
+  const parser = new JsonParser(jsonStr, logging);
+  const result = parser.parse();
+
+  if (logging) {
+    return result; // [parsedJson, logs] şeklinde döner
+  }
+
+  // String'e çevir veya obje olarak döndür
+  if (returnObjects) {
+    return result;
+  }
+
+  // JSON string'e çevir
+  const indent = 2;
+  const replacer = ensureAscii
+    ? (key: any, value: string) => {
+        if (typeof value === 'string') {
+          return value.replace(/[^\x00-\x7F]/g, char => {
+            return `\\u${`0000${char.charCodeAt(0).toString(16)}`.slice(-4)}`;
+          });
+        }
+        return value;
+      }
+    : undefined;
+
+  return JSON.stringify(result, replacer, indent);
+}
+
+/**
+ * JSON.parse benzeri fonksiyon, ancak bozuk JSON'ları da onarır
+ * @param {string} jsonStr - Parse edilecek JSON string'i
+ * @param {Object} options - Parse seçenekleri
+ * @param {boolean} options.skipJsonParse - true ise JSON.parse kontrolünü atlar
+ * @param {boolean} options.logging - true ise onarım loglarını da döner
+ * @returns {Object} Parse edilmiş JavaScript objesi
+ */
+export function loads(jsonStr: string, options = {}) {
+  return repairJson(jsonStr, { ...options, returnObjects: true });
+}

package/src/utils/json-util/json-util.ts

@@ -0,0 +1,104 @@
+import { isNil } from 'ramda';
+import {
+  IApiJsonRepairOption,
+  IApiJsonRepairResult,
+  IApiJsonUtil,
+} from '../../interface';
+import { loads, repairJson } from './json-repair';
+
+export class JsonUtil implements IApiJsonUtil {
+  /**
+   * @description json修复，用于提取大语言模型中的json数据
+   * @param {string} value
+   * @param {IApiJsonRepairOption} [options={}]
+   * @returns {*}  {(IData | IData[] | string)}
+   * @memberof JsonUtil
+   */
+  repairJson(
+    value: string,
+    options: IApiJsonRepairOption = {},
+  ): IData | IData[] | string {
+    return repairJson(value, options);
+  }
+
+  /**
+   * @description 加载字符串中的JSON数据，直接返回json数据对象
+   * @param {string} value
+   * @param {IApiJsonRepairOption} [options={}]
+   * @returns {*}  {(IData | IData[])}
+   * @memberof JsonUtil
+   */
+  loads(value: string, options: IApiJsonRepairOption = {}): IData | IData[] {
+    return loads(value, options);
+  }
+
+  /**
+   * @description 判断给定的值是否为 JSON 对象
+   * @param value
+   * @returns boolean
+   */
+  isJsonObject(value: unknown): boolean {
+    // 必须是 object 类型，不为 null，并且不是数组
+    if (typeof value !== 'object' || isNil(value) || Array.isArray(value)) {
+      return false;
+    }
+    // 排除常见的非纯对象类型，如 Date, RegExp, Function, DOM Element 等
+    if (value.constructor && value.constructor !== Object) {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * @description 判断给定的值是否为 JSON 数组
+   * @param value
+   * @returns boolean
+   */
+  isJsonArray(value: unknown): boolean {
+    // 1. 检查是否为 null 或 undefined
+    if (isNil(value)) {
+      return false;
+    }
+    if (Array.isArray(value)) {
+      return value.every(item => this.isJsonObject(item));
+    }
+    return false;
+  }
+
+  /**
+   * @description json修复，用于提取大语言模型中的json数据
+   * @param {string} value
+   * @param {IApiJsonRepairOption} [options={}]
+   * @returns {*}  {IApiJsonRepairResult}
+   * @memberof JsonUtil
+   */
+  parseJson(
+    value: string,
+    options: IApiJsonRepairOption = {},
+  ): IApiJsonRepairResult {
+    const data = loads(value, options);
+    if (data) {
+      let success: boolean = true;
+      const type = Array.isArray(data) ? 'jsonarray' : 'jsonobject';
+      if (type === 'jsonobject') {
+        success = this.isJsonObject(data);
+      } else if (type === 'jsonarray') {
+        success = this.isJsonArray(data);
+      }
+      return {
+        success,
+        data: success ? data : undefined,
+        data_type: success ? type : 'unknown',
+        message: success
+          ? ibiz.i18n.t('runtime.utils.jsonUtil.parseSuccess')
+          : ibiz.i18n.t('runtime.utils.jsonUtil.parseError'),
+      };
+    }
+    return {
+      success: false,
+      data: undefined,
+      data_type: 'unknown',
+      message: ibiz.i18n.t('runtime.utils.jsonUtil.parseError'),
+    };
+  }
+}