@dooboostore/simple-boot-http-server 1.0.24 → 1.0.25

package/dist/umd-bundle/websocket-client.umd.js

@@ -20,6 +20,7 @@ var dooboostoreSimpleBootHttpServerWebSocketClient = (() => {
   // src/websocket/WebSocketClient.ts
   var WebSocketClient_exports = {};
   __export(WebSocketClient_exports, {
+    ActionExpression: () => ActionExpression,
     Advice: () => Advice,
     AllCheckedValidatorArray: () => AllCheckedValidatorArray,
     AllUnCheckedValidatorArray: () => AllUnCheckedValidatorArray,
@@ -44,6 +45,7 @@ var dooboostoreSimpleBootHttpServerWebSocketClient = (() => {
     CountUnCheckedValidatorArray: () => CountUnCheckedValidatorArray,
     CssNode: () => CssNode,
     CssParser: () => CssParser,
+    DEFAULT_EXPRESSION_CONFIG: () => DEFAULT_EXPRESSION_CONFIG,
     DateUtils: () => DateUtils,
     Ellipse: () => Ellipse,
     EmptyValidator: () => EmptyValidator,
@@ -120,6 +122,8 @@ var dooboostoreSimpleBootHttpServerWebSocketClient = (() => {
     WrapPolygons: () => WrapPolygons,
     WrapRects: () => WrapRects,
     debounce: () => debounce,
+    debounceTimeIntervalLock: () => debounceTimeIntervalLock,
+    getExpression: () => getExpression,
     isAtRule: () => isAtRule,
     isCssCommentItem: () => isCssCommentItem,
     isCssDeclarationItem: () => isCssDeclarationItem,
@@ -471,7 +475,7 @@ var dooboostoreSimpleBootHttpServerWebSocketClient = (() => {
   })(ArrayUtils || (ArrayUtils = {}));
 
   // ../core/dist/esm/types.js
-  var isDefined = (value) => value !== void 0 && value !== null;
+  var isDefined = ValidUtils.isDefined;
 
   // ../core/dist/esm/parser/path/ObjectPathParser.js
   var Token = class {
@@ -5698,6 +5702,17 @@ var dooboostoreSimpleBootHttpServerWebSocketClient = (() => {
   }
 
   // ../core/dist/esm/message/index.js
+  var debounceTimeIntervalLock = (unlockChecker, unlocked, intervalTime, config) => {
+    const clearIntervalFn = config?.clearInterval || clearInterval;
+    const setIntervalFn = config?.setInterval || setInterval;
+    const nextIntervalId = setIntervalFn(() => {
+      if (unlockChecker()) {
+        clearIntervalFn(nextIntervalId);
+        unlocked();
+      }
+    }, intervalTime);
+    return nextIntervalId;
+  };
   var debounce = (fn, delay2, config) => {
     const setTimeoutFn = config?.setTimeout || setTimeout;
     const clearTimeoutFn = config?.clearTimeout || clearTimeout;
@@ -8321,7 +8336,7 @@ var dooboostoreSimpleBootHttpServerWebSocketClient = (() => {
   // ../core/dist/esm/schedule/Schedule.js
   var Schedule;
   ((Schedule2) => {
-    Schedule2.SYMBOL = Symbol("Schedule");
+    Schedule2.SYMBOL = Symbol.for("core:schedule-token");
   })(Schedule || (Schedule = {}));
   var ScheduleBase = class {
     constructor() {
@@ -8755,6 +8770,17 @@ var dooboostoreSimpleBootHttpServerWebSocketClient = (() => {
         Reflect.defineMetadata(metadataKey, value, target);
       }
     };
+    ReflectUtils2.copyMetadata = (from2, to, propertyKey) => {
+      const keys = propertyKey ? Reflect.getOwnMetadataKeys(from2, propertyKey) : Reflect.getOwnMetadataKeys(from2);
+      for (const key of keys) {
+        const data = propertyKey ? Reflect.getOwnMetadata(key, from2, propertyKey) : Reflect.getOwnMetadata(key, from2);
+        if (propertyKey) {
+          Reflect.defineMetadata(key, data, to, propertyKey);
+        } else {
+          Reflect.defineMetadata(key, data, to);
+        }
+      }
+    };
   })(ReflectUtils || (ReflectUtils = {}));
 
   // ../core/dist/esm/function/FunctionUtils.js
@@ -10666,6 +10692,160 @@ ${indentStr}}`;
     })(Path = Expression2.Path || (Expression2.Path = {}));
   })(Expression || (Expression = {}));
 
+  // ../core/dist/esm/expression/ActionExpression.js
+  var DEFAULT_EXPRESSION_CONFIG = {
+    "callReturn": { start: "{{=", end: "}}" },
+    "call": { start: "{{@", end: "}}" },
+    "replace": { start: "{{", end: "}}" }
+  };
+  var ActionExpression = class {
+    constructor(value, config) {
+      this.originalTemplate = value || "";
+      this.idToMarker = /* @__PURE__ */ new Map();
+      this.processedIds = /* @__PURE__ */ new Set();
+      this.expressions = [];
+      if (!value || typeof value !== "string") {
+        this.maskingTemplate = this.originalTemplate;
+        this.currentTemplate = this.originalTemplate;
+        return;
+      }
+      this.maskingTemplate = value;
+      this.currentTemplate = value;
+      const exprConfig = {
+        "callReturn": config?.expression?.["callReturn"] || DEFAULT_EXPRESSION_CONFIG["callReturn"],
+        "call": config?.expression?.call || DEFAULT_EXPRESSION_CONFIG.call,
+        "replace": config?.expression?.replace || DEFAULT_EXPRESSION_CONFIG.replace
+      };
+      const types = ["callReturn", "call", "replace"];
+      types.sort((a, b) => {
+        const startFirst = exprConfig[b].start;
+        const startLast = exprConfig[a].start;
+        const fLength = typeof startFirst === "string" ? startFirst.length : startFirst.source.length;
+        const lLength = typeof startLast === "string" ? startLast.length : startLast.source.length;
+        return fLength - lLength;
+      });
+      for (const type of types) {
+        const marker = exprConfig[type];
+        if (marker) {
+          this.processExpressionType(type, marker.start, marker.end);
+        }
+      }
+      this.sortExpressionsByPosition();
+      this.maskingTemplate = this.currentTemplate;
+    }
+    sortExpressionsByPosition() {
+      this.expressions.forEach((expr) => {
+        const index = this.originalTemplate.indexOf(expr.original);
+        expr.index = index >= 0 ? index : 0;
+      });
+      this.expressions.sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+    }
+    processExpressionType(type, start, end) {
+      const getPattern = (v) => {
+        if (v instanceof RegExp) {
+          return v.source;
+        }
+        return v.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      };
+      const escapedStart = getPattern(start);
+      const escapedEnd = getPattern(end);
+      const regex = new RegExp(`${escapedStart}\\s*([\\s\\S]+?)\\s*${escapedEnd}`, "g");
+      let match;
+      const valueToMatch = this.currentTemplate;
+      while ((match = regex.exec(valueToMatch)) !== null) {
+        this.addExpression(match, type);
+      }
+    }
+    addExpression(match, type) {
+      const id = Math.random().toString(36).substr(2, 9);
+      const original = match[0];
+      const rawScript = match[1];
+      const marker = `__EXPR_${id}__`;
+      const expressionStart = original.substring(0, original.indexOf(rawScript));
+      const expressionEnd = original.substring(original.indexOf(rawScript) + rawScript.length);
+      this.idToMarker.set(id, marker);
+      this.currentTemplate = this.currentTemplate.replace(original, marker);
+      this.expressions.push({
+        id,
+        type,
+        original,
+        script: rawScript.trim(),
+        expressionStart,
+        expressionEnd
+      });
+    }
+    replace(idOrExpr, valueOrCallback) {
+      const id = typeof idOrExpr === "string" ? idOrExpr : idOrExpr.id;
+      let expr;
+      if (typeof valueOrCallback === "function") {
+        expr = this.expressions.find((e) => e.id === id);
+        if (!expr) return this.getUnprocessedTemplate();
+      }
+      const value = typeof valueOrCallback === "function" ? valueOrCallback(expr) : valueOrCallback;
+      const marker = this.idToMarker.get(id);
+      if (marker) {
+        this.processedIds.add(id);
+        this.currentTemplate = this.currentTemplate.replace(marker, value);
+      }
+      return this.getUnprocessedTemplate();
+    }
+    getExpressions(typeOrOptions) {
+      if (!typeOrOptions) {
+        return this.expressions;
+      }
+      if (typeof typeOrOptions === "string") {
+        return this.expressions.filter((expr) => expr.type === typeOrOptions);
+      }
+      const options = typeOrOptions;
+      return this.expressions.filter((expr) => {
+        if (options.type && expr.type !== options.type) return false;
+        return true;
+      });
+    }
+    getFirstExpression(typeOrOptions) {
+      if (!typeOrOptions) {
+        return this.getExpressions()[0];
+      }
+      if (typeof typeOrOptions === "string") {
+        return this.getExpressions(typeOrOptions)[0];
+      }
+      return this.getExpressions(typeOrOptions)[0];
+    }
+    getOriginalTemplate() {
+      return this.originalTemplate;
+    }
+    getMaskingTemplate() {
+      return this.maskingTemplate;
+    }
+    getCurrentTemplate() {
+      return this.currentTemplate;
+    }
+    toResult() {
+      return this.getUnprocessedTemplate();
+    }
+    getUnprocessedTemplate() {
+      let result = this.currentTemplate;
+      for (const expr of this.expressions) {
+        if (!this.processedIds.has(expr.id)) {
+          const m = this.idToMarker.get(expr.id);
+          if (m) {
+            result = result.replace(m, expr.original);
+          }
+        }
+      }
+      return result;
+    }
+  };
+  function getExpression(value, config) {
+    const ae = new ActionExpression(value, config);
+    return {
+      originalTemplate: ae.getOriginalTemplate(),
+      maskingTemplate: ae.getMaskingTemplate(),
+      expressions: ae.getExpressions(),
+      replace: (id, value2) => ae.replace(id, value2)
+    };
+  }
+
   // src/websocket/WebSocketClient.ts
   var WebSocketClient = class {
     constructor(connection, config) {