uview-ultra 4.5.46

package/libs/luch-request/utils/clone.js

@@ -0,0 +1,264 @@
+/* eslint-disable */
+var clone = (function() {
+  'use strict';
+
+  function _instanceof(obj, type) {
+    return type != null && obj instanceof type;
+  }
+
+  var nativeMap;
+  try {
+    nativeMap = Map;
+  } catch(_) {
+    // maybe a reference error because no `Map`. Give it a dummy value that no
+    // value will ever be an instanceof.
+    nativeMap = function() {};
+  }
+
+  var nativeSet;
+  try {
+    nativeSet = Set;
+  } catch(_) {
+    nativeSet = function() {};
+  }
+
+  var nativePromise;
+  try {
+    nativePromise = Promise;
+  } catch(_) {
+    nativePromise = function() {};
+  }
+
+  /**
+   * Clones (copies) an Object using deep copying.
+   *
+   * This function supports circular references by default, but if you are certain
+   * there are no circular references in your object, you can save some CPU time
+   * by calling clone(obj, false).
+   *
+   * Caution: if `circular` is false and `parent` contains circular references,
+   * your program may enter an infinite loop and crash.
+   *
+   * @param `parent` - the object to be cloned
+   * @param `circular` - set to true if the object to be cloned may contain
+   *    circular references. (optional - true by default)
+   * @param `depth` - set to a number if the object is only to be cloned to
+   *    a particular depth. (optional - defaults to Infinity)
+   * @param `prototype` - sets the prototype to be used when cloning an object.
+   *    (optional - defaults to parent prototype).
+   * @param `includeNonEnumerable` - set to true if the non-enumerable properties
+   *    should be cloned as well. Non-enumerable properties on the prototype
+   *    chain will be ignored. (optional - false by default)
+   */
+  function clone(parent, circular, depth, prototype, includeNonEnumerable) {
+    if (typeof circular === 'object') {
+      depth = circular.depth;
+      prototype = circular.prototype;
+      includeNonEnumerable = circular.includeNonEnumerable;
+      circular = circular.circular;
+    }
+    // maintain two arrays for circular references, where corresponding parents
+    // and children have the same index
+    var allParents = [];
+    var allChildren = [];
+
+    var useBuffer = typeof Buffer != 'undefined';
+
+    if (typeof circular == 'undefined')
+      circular = true;
+
+    if (typeof depth == 'undefined')
+      depth = Infinity;
+
+    // recurse this function so we don't reset allParents and allChildren
+    function _clone(parent, depth) {
+      // cloning null always returns null
+      if (parent === null)
+        return null;
+
+      if (depth === 0)
+        return parent;
+
+      var child;
+      var proto;
+      if (typeof parent != 'object') {
+        return parent;
+      }
+
+      if (_instanceof(parent, nativeMap)) {
+        child = new nativeMap();
+      } else if (_instanceof(parent, nativeSet)) {
+        child = new nativeSet();
+      } else if (_instanceof(parent, nativePromise)) {
+        child = new nativePromise(function (resolve, reject) {
+          parent.then(function(value) {
+            resolve(_clone(value, depth - 1));
+          }, function(err) {
+            reject(_clone(err, depth - 1));
+          });
+        });
+      } else if (clone.__isArray(parent)) {
+        child = [];
+      } else if (clone.__isRegExp(parent)) {
+        child = new RegExp(parent.source, __getRegExpFlags(parent));
+        if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+      } else if (clone.__isDate(parent)) {
+        child = new Date(parent.getTime());
+      } else if (useBuffer && Buffer.isBuffer(parent)) {
+        if (Buffer.from) {
+          // Node.js >= 5.10.0
+          child = Buffer.from(parent);
+        } else {
+          // Older Node.js versions
+          child = new Buffer(parent.length);
+          parent.copy(child);
+        }
+        return child;
+      } else if (_instanceof(parent, Error)) {
+        child = Object.create(parent);
+      } else {
+        if (typeof prototype == 'undefined') {
+          proto = Object.getPrototypeOf(parent);
+          child = Object.create(proto);
+        }
+        else {
+          child = Object.create(prototype);
+          proto = prototype;
+        }
+      }
+
+      if (circular) {
+        var index = allParents.indexOf(parent);
+
+        if (index != -1) {
+          return allChildren[index];
+        }
+        allParents.push(parent);
+        allChildren.push(child);
+      }
+
+      if (_instanceof(parent, nativeMap)) {
+        parent.forEach(function(value, key) {
+          var keyChild = _clone(key, depth - 1);
+          var valueChild = _clone(value, depth - 1);
+          child.set(keyChild, valueChild);
+        });
+      }
+      if (_instanceof(parent, nativeSet)) {
+        parent.forEach(function(value) {
+          var entryChild = _clone(value, depth - 1);
+          child.add(entryChild);
+        });
+      }
+
+      for (var i in parent) {
+        var attrs = Object.getOwnPropertyDescriptor(parent, i);
+        if (attrs) {
+          child[i] = _clone(parent[i], depth - 1);
+        }
+
+        try {
+          var objProperty = Object.getOwnPropertyDescriptor(parent, i);
+          if (objProperty.set === 'undefined') {
+            // no setter defined. Skip cloning this property
+            continue;
+          }
+          child[i] = _clone(parent[i], depth - 1);
+        } catch(e){
+          if (e instanceof TypeError) {
+            // when in strict mode, TypeError will be thrown if child[i] property only has a getter
+            // we can't do anything about this, other than inform the user that this property cannot be set.
+            continue
+          } else if (e instanceof ReferenceError) {
+            //this may happen in non strict mode
+            continue
+          }
+        }
+
+      }
+
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(parent);
+        for (var i = 0; i < symbols.length; i++) {
+          // Don't need to worry about cloning a symbol because it is a primitive,
+          // like a number or string.
+          var symbol = symbols[i];
+          var descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
+          if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
+            continue;
+          }
+          child[symbol] = _clone(parent[symbol], depth - 1);
+          Object.defineProperty(child, symbol, descriptor);
+        }
+      }
+
+      if (includeNonEnumerable) {
+        var allPropertyNames = Object.getOwnPropertyNames(parent);
+        for (var i = 0; i < allPropertyNames.length; i++) {
+          var propertyName = allPropertyNames[i];
+          var descriptor = Object.getOwnPropertyDescriptor(parent, propertyName);
+          if (descriptor && descriptor.enumerable) {
+            continue;
+          }
+          child[propertyName] = _clone(parent[propertyName], depth - 1);
+          Object.defineProperty(child, propertyName, descriptor);
+        }
+      }
+
+      return child;
+    }
+
+    return _clone(parent, depth);
+  }
+
+  /**
+   * Simple flat clone using prototype, accepts only objects, usefull for property
+   * override on FLAT configuration object (no nested props).
+   *
+   * USE WITH CAUTION! This may not behave as you wish if you do not know how this
+   * works.
+   */
+  clone.clonePrototype = function clonePrototype(parent) {
+    if (parent === null)
+      return null;
+
+    var c = function () {};
+    c.prototype = parent;
+    return new c();
+  };
+
+// private utility functions
+
+  function __objToStr(o) {
+    return Object.prototype.toString.call(o);
+  }
+  clone.__objToStr = __objToStr;
+
+  function __isDate(o) {
+    return typeof o === 'object' && __objToStr(o) === '[object Date]';
+  }
+  clone.__isDate = __isDate;
+
+  function __isArray(o) {
+    return typeof o === 'object' && __objToStr(o) === '[object Array]';
+  }
+  clone.__isArray = __isArray;
+
+  function __isRegExp(o) {
+    return typeof o === 'object' && __objToStr(o) === '[object RegExp]';
+  }
+  clone.__isRegExp = __isRegExp;
+
+  function __getRegExpFlags(re) {
+    var flags = '';
+    if (re.global) flags += 'g';
+    if (re.ignoreCase) flags += 'i';
+    if (re.multiline) flags += 'm';
+    return flags;
+  }
+  clone.__getRegExpFlags = __getRegExpFlags;
+
+  return clone;
+})();
+
+export default clone

package/libs/luch-request/utils/clone.uts

@@ -0,0 +1,38 @@
+/**
+ * uts 兼容的简易 clone：克隆普通对象(UTSJSONObject)与数组，函数按引用复制
+ * 不处理 Buffer/Map/Set/RegExp（config 对象用不到）
+ */
+
+function clone(obj: any | null): any | null {
+    if (obj == null || typeof obj !== 'object') {
+        return obj
+    }
+
+    if (obj instanceof Date) {
+        return new Date((obj as Date).getTime())
+    }
+
+    if (Array.isArray(obj)) {
+        const src = obj as Array<any>
+        const arr: Array<any | null> = []
+        for (let i = 0; i < src.length; i++) {
+            arr.push(clone(src[i]))
+        }
+        return arr
+    }
+
+    const o = obj as UTSJSONObject
+    const result: UTSJSONObject = {} as UTSJSONObject
+    UTSJSONObject.keys(o).forEach((key: string) => {
+        const val = o[key]
+        if (val != null && typeof val === 'object') {
+            result[key] = clone(val)
+        } else {
+            // 基本类型与函数：按引用/值复制
+            result[key] = val
+        }
+    })
+    return result
+}
+
+export default clone

package/libs/luch-request/utils.js

@@ -0,0 +1,131 @@
+'use strict'
+
+// utils is a library of generic helper functions non-specific to axios
+
+const { toString } = Object.prototype
+
+/**
+ * Determine if a value is an Array
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an Array, otherwise false
+ */
+export function isArray(val) {
+    return toString.call(val) === '[object Array]'
+}
+
+/**
+ * Determine if a value is an Object
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is an Object, otherwise false
+ */
+export function isObject(val) {
+    return val !== null && typeof val === 'object'
+}
+
+/**
+ * Determine if a value is a Date
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a Date, otherwise false
+ */
+export function isDate(val) {
+    return toString.call(val) === '[object Date]'
+}
+
+/**
+ * Determine if a value is a URLSearchParams object
+ *
+ * @param {Object} val The value to test
+ * @returns {boolean} True if value is a URLSearchParams object, otherwise false
+ */
+export function isURLSearchParams(val) {
+    return typeof URLSearchParams !== 'undefined' && val instanceof URLSearchParams
+}
+
+/**
+ * Iterate over an Array or an Object invoking a function for each item.
+ *
+ * If `obj` is an Array callback will be called passing
+ * the value, index, and complete array for each item.
+ *
+ * If 'obj' is an Object callback will be called passing
+ * the value, key, and complete object for each property.
+ *
+ * @param {Object|Array} obj The object to iterate
+ * @param {Function} fn The callback to invoke for each item
+ */
+export function forEach(obj, fn) {
+    // Don't bother if no value provided
+    if (obj === null || typeof obj === 'undefined') {
+        return
+    }
+
+    // Force an array if not already something iterable
+    if (typeof obj !== 'object') {
+    /* eslint no-param-reassign:0 */
+        obj = [obj]
+    }
+
+    if (isArray(obj)) {
+    // Iterate over array values
+        for (let i = 0, l = obj.length; i < l; i++) {
+            fn.call(null, obj[i], i, obj)
+        }
+    } else {
+    // Iterate over object keys
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                fn.call(null, obj[key], key, obj)
+            }
+        }
+    }
+}
+
+/**
+ * 是否为boolean 值
+ * @param val
+ * @returns {boolean}
+ */
+export function isBoolean(val) {
+    return typeof val === 'boolean'
+}
+
+/**
+ * 是否为真正的对象{} new Object
+ * @param {any} obj - 检测的对象
+ * @returns {boolean}
+ */
+export function isPlainObject(obj) {
+    return Object.prototype.toString.call(obj) === '[object Object]'
+}
+
+/**
+ * Function equal to merge with the difference being that no reference
+ * to original objects is kept.
+ *
+ * @see merge
+ * @param {Object} obj1 Object to merge
+ * @returns {Object} Result of all merge properties
+ */
+export function deepMerge(/* obj1, obj2, obj3, ... */) {
+    const result = {}
+    function assignValue(val, key) {
+        if (typeof result[key] === 'object' && typeof val === 'object') {
+            result[key] = deepMerge(result[key], val)
+        } else if (typeof val === 'object') {
+            result[key] = deepMerge({}, val)
+        } else {
+            result[key] = val
+        }
+    }
+    for (let i = 0, l = arguments.length; i < l; i++) {
+        forEach(arguments[i], assignValue)
+    }
+    return result
+}
+
+export function isUndefined(val) {
+    return typeof val === 'undefined'
+}

package/libs/luch-request/utils.uts

@@ -0,0 +1,66 @@
+'use strict'
+
+// uni-app x (uts) 兼容的通用工具（原 axios/luch-request utils 的 uts 重写）
+// 保持导出函数名与语义不变；内部改用 UTSJSONObject / Array.isArray / instanceof 等 uts 支持的写法
+
+export function isArray(val: any | null): boolean {
+    return Array.isArray(val)
+}
+
+export function isObject(val: any | null): boolean {
+    return val != null && typeof val === 'object'
+}
+
+export function isDate(val: any | null): boolean {
+    return val instanceof Date
+}
+
+export function isUndefined(val: any | null): boolean {
+    return val == null
+}
+
+export function isBoolean(val: any | null): boolean {
+    return typeof val === 'boolean'
+}
+
+export function isPlainObject(obj: any | null): boolean {
+    return obj != null && typeof obj === 'object' && !Array.isArray(obj) && !(obj instanceof Date)
+}
+
+// PLACEHOLDER_UTILS
+// 遍历数组或 UTSJSONObject，回调签名 (val, key, obj)
+export function forEach(obj: any | null, fn: (val: any | null, key: any, obj: any | null) => void): void {
+    if (obj == null) {
+        return
+    }
+    if (Array.isArray(obj)) {
+        const arr = obj as Array<any>
+        for (let i = 0; i < arr.length; i++) {
+            fn(arr[i], i, obj)
+        }
+    } else if (typeof obj === 'object') {
+        const o = obj as UTSJSONObject
+        UTSJSONObject.keys(o).forEach((key: string) => {
+            fn(o[key], key, obj)
+        })
+    } else {
+        fn(obj, 0, obj)
+    }
+}
+
+// 深合并两个 UTSJSONObject（source 覆盖 target），不保留原引用
+export function deepMerge(target: UTSJSONObject, source: UTSJSONObject): UTSJSONObject {
+    const result: UTSJSONObject = UTSJSONObject.assign({} as UTSJSONObject, target)
+    UTSJSONObject.keys(source).forEach((key: string) => {
+        const sv = source[key]
+        const rv = result[key]
+        const svObj = sv != null && typeof sv === 'object' && !Array.isArray(sv) && !(sv instanceof Date)
+        const rvObj = rv != null && typeof rv === 'object' && !Array.isArray(rv) && !(rv instanceof Date)
+        if (svObj && rvObj) {
+            result[key] = deepMerge(rv as UTSJSONObject, sv as UTSJSONObject)
+        } else {
+            result[key] = sv
+        }
+    })
+    return result
+}

package/libs/marked-uts/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kux-Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/libs/marked-uts/common/Hooks.uts

@@ -0,0 +1,71 @@
+import { _defaults } from './defaults';
+import { Lexer } from './Lexer';
+import { Parser } from './Parser';
+import { MarkedOptions, Token, TokensList, I_Hooks, I_Renderer, I_TextRenderer, NodesToken } from '../utssdk/interface';
+
+export class _Hooks implements I_Hooks {
+	options: MarkedOptions;
+	block: boolean | null = null;
+	
+	constructor(options: MarkedOptions | null = null) {
+	    this.options = options ?? _defaults;
+	}
+	
+	static passThroughHooks = new Set([
+		'preprocess',
+		'postprocess',
+		'processAllTokens',
+	]);
+	
+	/**
+	   * Process markdown before marked
+	   */
+	preprocess(markdown: string): string {
+		return markdown;
+	}
+	
+	/**
+	   * Process HTML after marked is finished
+	   */
+	postprocess(html: string): string {
+		return html;
+	}
+	
+	/**
+	   * Process all tokens before walk tokens
+	   */
+	processAllTokens(tokens: NodesToken[] | TokensList): NodesToken[] | TokensList {
+		return tokens;
+	}
+	
+	/**
+	   * Provide function to tokenize markdown
+	   */
+	provideLexer(): ((src: string, options?: MarkedOptions) => NodesToken[]) | ((src: string, options?: MarkedOptions) => TokensList) {
+		if (this.block == true) {
+			return (src: string, options?: MarkedOptions): TokensList => {
+				return Lexer.lex(src, options);
+			};
+		}
+		
+		return (src: string, options?: MarkedOptions): NodesToken[] => {
+			return Lexer.lexInline(src, options);
+		};
+	}
+	
+	/**
+	   * Provide function to parse tokens
+	   */
+	provideParser(): ((tokens: NodesToken[], options?: MarkedOptions) => string) {
+		// return this.block == true ? _Parser.parse : _Parser.parseInline;
+		if (this.block == true) {
+			return (tokens: NodesToken[], options?: MarkedOptions): string => {
+				return Parser.parse(tokens, options);
+			};
+		}
+		
+		return (tokens: NodesToken[], options?: MarkedOptions): string => {
+			return Parser.parseInline(tokens, options);
+		};
+	}
+}