@lark-apaas/miaoda-inspector 0.1.0-alpha.1

package/dist/lib/MiaodaInspector/MiaodaInspector.js

@@ -0,0 +1,447 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "MiaodaInspector", {
+  enumerable: true,
+  get: function() {
+    return MiaodaInspector;
+  }
+});
+const _jsxruntime = require("react/jsx-runtime");
+const _react = /* @__PURE__ */ _interop_require_wildcard(require("react"));
+const _Inspector = require("../Inspector");
+const _Overlay = require("../Inspector/Overlay");
+const _utils = require("../utils");
+require("./MiaodaInspector.css");
+const _configmapper = require("../utils/config-mapper");
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== "function")
+    return null;
+  var cacheBabelInterop = /* @__PURE__ */ new WeakMap();
+  var cacheNodeInterop = /* @__PURE__ */ new WeakMap();
+  return (_getRequireWildcardCache = function(nodeInterop2) {
+    return nodeInterop2 ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+    return {
+      default: obj
+    };
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+function _object_spread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys2 = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+      }));
+    }
+    ownKeys2.forEach(function(key) {
+      _define_property(target, key, source[key]);
+    });
+  }
+  return target;
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) {
+      symbols = symbols.filter(function(sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _object_spread_props(target, source) {
+  source = source != null ? source : {};
+  if (Object.getOwnPropertyDescriptors) {
+    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+  } else {
+    ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function safeClassName(el) {
+  const cn = el === null || el === void 0 ? void 0 : el.className;
+  if (typeof cn === "string") {
+    return cn;
+  }
+  if (typeof (cn === null || cn === void 0 ? void 0 : cn.baseVal) === "string") {
+    return cn.baseVal;
+  }
+  return "";
+}
+function analyzeTextOnlyNode(element, componentName, canUseNewInspector) {
+  if (!element || componentName && componentName[0] === componentName[0].toUpperCase() || !canUseNewInspector || element instanceof SVGElement) {
+    return {
+      hasOnlyTextNodes: false,
+      textContent: null
+    };
+  }
+  try {
+    const childNodes = Array.from(element.childNodes);
+    const textNodes = childNodes.filter((node) => node.nodeType === Node.TEXT_NODE);
+    const hasOnlyText = childNodes.length > 0 && textNodes.length === childNodes.length;
+    return {
+      hasOnlyTextNodes: hasOnlyText,
+      textContent: hasOnlyText ? element.textContent : null
+    };
+  } catch (e) {
+    console.error("Error analyzing text-only node:", e);
+  }
+  return {
+    hasOnlyTextNodes: false,
+    textContent: null
+  };
+}
+const getElementCoordinates = (element) => {
+  const boundingClientRect = element === null || element === void 0 ? void 0 : element.getBoundingClientRect();
+  const computedStyle = element ? window.getComputedStyle(element) : null;
+  const marginLeft = computedStyle ? parseFloat(computedStyle.marginLeft) || 0 : 0;
+  const marginRight = computedStyle ? parseFloat(computedStyle.marginRight) || 0 : 0;
+  const marginTop = computedStyle ? parseFloat(computedStyle.marginTop) || 0 : 0;
+  const marginBottom = computedStyle ? parseFloat(computedStyle.marginBottom) || 0 : 0;
+  const totalWidth = boundingClientRect ? boundingClientRect.width + marginLeft + marginRight : 0;
+  const totalHeight = boundingClientRect ? boundingClientRect.height + marginTop + marginBottom : 0;
+  const adjustedTop = boundingClientRect ? boundingClientRect.top - marginTop : 0;
+  const adjustedLeft = boundingClientRect ? boundingClientRect.left - marginLeft : 0;
+  const adjustedRight = boundingClientRect ? boundingClientRect.right + marginRight : 0;
+  const adjustedBottom = boundingClientRect ? boundingClientRect.bottom + marginBottom : 0;
+  return {
+    width: totalWidth,
+    height: totalHeight,
+    top: adjustedTop,
+    left: adjustedLeft,
+    right: adjustedRight,
+    bottom: adjustedBottom
+  };
+};
+const selectedElementMap = /* @__PURE__ */ new Map();
+function elementInfoToKey(relativePath, lineNumber, columnNumber) {
+  return `${relativePath}_${lineNumber}_${columnNumber}`;
+}
+const enableInner = (() => {
+  var _localStorage;
+  return ((_localStorage = localStorage) === null || _localStorage === void 0 ? void 0 : _localStorage.getItem("miaoda-inspector-inner")) === "true";
+})();
+function MiaodaInspector(props) {
+  const [_active, setActive] = (0, _react.useState)(false);
+  const [inBody, setInBody] = (0, _react.useState)(true);
+  const active = (_active || enableInner) && inBody;
+  const canUseNewInspector = (0, _react.useRef)(false);
+  const clickOverlayRef = (0, _react.useRef)(null);
+  const defaultUIConfig = props.theme.themeToken;
+  const styleConfigs = (0, _configmapper.getAllStyleConfigs)(defaultUIConfig);
+  const mouseleave = (0, _react.useCallback)(() => {
+    setInBody(false);
+  }, []);
+  const mouseenter = (0, _react.useCallback)(() => {
+    setInBody(true);
+  }, []);
+  const handleMessage = (0, _react.useCallback)((event) => {
+    const { data } = event;
+    if ((0, _utils.isIncomingMessage)(data, "InitConfig")) {
+      const { inspectorActive, userToken, appId, inspectorVersion } = data.data;
+      if (inspectorActive !== void 0) {
+        setActive(inspectorActive);
+        if (inspectorActive === false) {
+          var _clickOverlayRef_current;
+          (_clickOverlayRef_current = clickOverlayRef.current) === null || _clickOverlayRef_current === void 0 ? void 0 : _clickOverlayRef_current.remove();
+          clickOverlayRef.current = null;
+        }
+      }
+      if (userToken !== void 0) {
+        window.MIAODA_BUILTIN_TTT = userToken;
+      }
+      if (appId !== void 0) {
+        window.MIAODA_APP_ID = appId;
+      }
+      (0, _utils.postMessage)({
+        type: "InspectorUIConfig",
+        data: defaultUIConfig
+      });
+      if (inspectorVersion === "2") {
+        canUseNewInspector.current = true;
+      }
+    } else if ((0, _utils.isIncomingMessage)(data, "ClearSelected")) {
+      var _clickOverlayRef_current1;
+      const { keepModifications = false } = data.data;
+      (_clickOverlayRef_current1 = clickOverlayRef.current) === null || _clickOverlayRef_current1 === void 0 ? void 0 : _clickOverlayRef_current1.remove();
+      clickOverlayRef.current = null;
+      if (canUseNewInspector.current && !keepModifications) {
+        for (const [_, selectedElement] of selectedElementMap.entries()) {
+          if (selectedElement.element) {
+            if (selectedElement.originalState.textContent) {
+              selectedElement.element.textContent = selectedElement.originalState.textContent;
+            }
+            if (selectedElement.originalState.className && !(selectedElement.element instanceof SVGElement)) {
+              selectedElement.element.className = selectedElement.originalState.className;
+            }
+          }
+          if (selectedElement.dispose) {
+            selectedElement.dispose();
+          }
+        }
+        selectedElementMap.clear();
+      }
+    } else if ((0, _utils.isIncomingMessage)(data, "EditText")) {
+      const { elementId, textContent } = data.data;
+      const selectedElement = selectedElementMap.get(elementId);
+      if (selectedElement && selectedElement.element) {
+        selectedElement.element.textContent = textContent;
+      }
+    } else if ((0, _utils.isIncomingMessage)(data, "EditStyle")) {
+      const { elementId, styles } = data.data;
+      const selectedElement = selectedElementMap.get(elementId);
+      if (selectedElement && selectedElement.element) {
+        const { element } = selectedElement;
+        for (const [property] of Object.entries(styles)) {
+          if (!(property in selectedElement.originalState.styles)) {
+            selectedElement.originalState.styles[property] = element.style.getPropertyValue(property);
+          }
+        }
+        for (const [property, value] of Object.entries(styles)) {
+          element.style.setProperty(property, value);
+        }
+        const existingDispose = selectedElement.dispose;
+        const styleDispose = () => {
+          for (const [property, value] of Object.entries(selectedElement.originalState.styles)) {
+            if (value) {
+              element.style.setProperty(property, value);
+            } else {
+              element.style.removeProperty(property);
+            }
+          }
+        };
+        selectedElement.dispose = () => {
+          styleDispose();
+          if (existingDispose) {
+            existingDispose();
+          }
+        };
+      }
+    } else if ((0, _utils.isIncomingMessage)(data, "EditClassName")) {
+      const { elementId, className } = data.data;
+      const selectedElement = selectedElementMap.get(elementId);
+      if (selectedElement && selectedElement.element) {
+        const { element } = selectedElement;
+        if (selectedElement.originalState.className === void 0) {
+          selectedElement.originalState.className = safeClassName(element);
+        }
+        element.className = (0, _utils.cx)(element.className, className);
+        const existingDispose = selectedElement.dispose;
+        const classDispose = () => {
+          if (selectedElement.originalState.className) {
+            element.className = selectedElement.originalState.className;
+          }
+        };
+        selectedElement.dispose = () => {
+          classDispose();
+          if (existingDispose) {
+            existingDispose();
+          }
+        };
+      }
+    }
+  }, [
+    defaultUIConfig
+  ]);
+  (0, _react.useEffect)(() => {
+    document.body.addEventListener("mouseleave", mouseleave, false);
+    document.body.addEventListener("mouseenter", mouseenter, false);
+    const handleScroll = () => {
+      var _clickOverlayRef_current;
+      (_clickOverlayRef_current = clickOverlayRef.current) === null || _clickOverlayRef_current === void 0 ? void 0 : _clickOverlayRef_current.remove();
+      clickOverlayRef.current = null;
+      (0, _utils.postMessage)({
+        type: "PageScroll",
+        data: {}
+      });
+    };
+    window.addEventListener("scroll", handleScroll, true);
+    return () => {
+      document.body.removeEventListener("mouseleave", mouseleave, false);
+      document.body.removeEventListener("mouseenter", mouseenter, false);
+      window.removeEventListener("scroll", handleScroll, true);
+    };
+  }, []);
+  (0, _react.useEffect)(() => {
+    window.addEventListener("message", handleMessage);
+    return () => {
+      window.removeEventListener("message", handleMessage);
+    };
+  }, []);
+  (0, _react.useEffect)(() => {
+    (0, _utils.postMessage)({
+      type: "PageMounted",
+      data: {
+        version: "0.1.0",
+        theme: props.theme
+      }
+    });
+  }, []);
+  const selectInspectorElement = (0, _react.useCallback)((params) => {
+    var _clickOverlayRef_current;
+    const { codeInfo, element, name, title } = params;
+    const coords = getElementCoordinates(element);
+    const textInfo = analyzeTextOnlyNode(element, name, canUseNewInspector.current);
+    const fontSizeInfo = (0, _utils.calculateFontSizeInfo)(element, name, canUseNewInspector.current, styleConfigs);
+    const fontWeightInfo = (0, _utils.calculateFontWeightInfo)(element, name, canUseNewInspector.current, styleConfigs);
+    const borderRadiusInfo = (0, _utils.calculateBorderRadiusInfo)(element, name, canUseNewInspector.current, styleConfigs);
+    const borderWidthInfo = (0, _utils.calculateBorderWidthInfo)(element, name, canUseNewInspector.current, styleConfigs);
+    const textAlignInfo = (0, _utils.calculateTextAlignInfo)(element, name, canUseNewInspector.current, styleConfigs);
+    const paddingInfo = (0, _utils.calculatePaddingInfo)(element, name, canUseNewInspector.current, styleConfigs);
+    const marginInfo = (0, _utils.calculateMarginInfo)(element, name, canUseNewInspector.current, styleConfigs);
+    const colorInfo = (0, _utils.calculateColorInfo)(element, name, canUseNewInspector.current, styleConfigs);
+    const backgroundColorInfo = (0, _utils.calculateBackgroundColorInfo)(element, name, canUseNewInspector.current, styleConfigs);
+    const borderColorInfo = (0, _utils.calculateBorderColorInfo)(element, name, canUseNewInspector.current, styleConfigs);
+    const id = elementInfoToKey(codeInfo.relativePath, codeInfo.lineNumber, codeInfo.columnNumber);
+    const selectElement = selectedElementMap.has(id);
+    if (!selectElement) {
+      selectedElementMap.set(id, {
+        elementId: id,
+        element,
+        originalState: {
+          textContent: textInfo.textContent,
+          className: safeClassName(element),
+          styles: {}
+        }
+      });
+    }
+    if (textInfo.hasOnlyTextNodes && canUseNewInspector.current) {
+      element.setAttribute("contenteditable", "true");
+      element.focus();
+      const TextUpdate = () => {
+        (0, _utils.postMessage)({
+          type: "TextUpdate",
+          data: {
+            elementId: id,
+            textContent: element.textContent
+          }
+        });
+      };
+      const dispose = () => {
+        element.removeAttribute("contenteditable");
+        element.removeEventListener("input", TextUpdate);
+      };
+      element.addEventListener("input", TextUpdate);
+      const _selectElement = selectedElementMap.get(id);
+      if (_selectElement) {
+        selectedElementMap.set(id, _object_spread_props(_object_spread({}, _selectElement), {
+          dispose
+        }));
+      }
+    }
+    var _element_id;
+    (0, _utils.postMessage)({
+      type: "SelectInspectorElement",
+      data: _object_spread_props(_object_spread({}, codeInfo), {
+        // 移除打头的 /
+        relativePath: codeInfo.relativePath,
+        tagName: element === null || element === void 0 ? void 0 : element.tagName,
+        componentName: name,
+        className: safeClassName(element),
+        id: (_element_id = element === null || element === void 0 ? void 0 : element.id) !== null && _element_id !== void 0 ? _element_id : "",
+        x: coords.left,
+        y: coords.top,
+        width: coords.width,
+        height: coords.height,
+        top: coords.top,
+        right: coords.right,
+        bottom: coords.bottom,
+        left: coords.left,
+        elementId: id,
+        textContent: textInfo.hasOnlyTextNodes ? textInfo.textContent : null,
+        fontSize: fontSizeInfo,
+        fontWeight: fontWeightInfo,
+        borderRadius: borderRadiusInfo,
+        borderWidth: borderWidthInfo,
+        textAlign: textAlignInfo,
+        padding: paddingInfo,
+        margin: marginInfo,
+        color: colorInfo,
+        backgroundColor: backgroundColorInfo,
+        borderColor: borderColorInfo,
+        metadata: codeInfo.metadata
+      })
+    });
+    (_clickOverlayRef_current = clickOverlayRef.current) === null || _clickOverlayRef_current === void 0 ? void 0 : _clickOverlayRef_current.remove();
+    clickOverlayRef.current = null;
+    const clickOverlay = new _Overlay.ClickOverlay(() => {
+      const _coords = getElementCoordinates(element);
+      (0, _utils.postMessage)({
+        type: "ElementResize",
+        data: _object_spread({
+          elementId: id
+        }, _coords)
+      });
+    });
+    clickOverlayRef.current = clickOverlay;
+    clickOverlay.highlight(element, title);
+  }, []);
+  const handleCodeInfo = (0, _react.useCallback)((name, info) => {
+    const relativePath = (info === null || info === void 0 ? void 0 : info.startsWith(props.cwd)) ? info.replace(props.cwd, "") : info;
+    var _relativePath_replace;
+    return [
+      name,
+      (_relativePath_replace = relativePath === null || relativePath === void 0 ? void 0 : relativePath.replace(/^\//, "")) !== null && _relativePath_replace !== void 0 ? _relativePath_replace : ""
+    ];
+  }, [
+    props.cwd
+  ]);
+  return /* @__PURE__ */ (0, _jsxruntime.jsx)(_Inspector.Inspector, {
+    disable: false,
+    active,
+    onClickElement: selectInspectorElement,
+    handleCodeInfo,
+    onActiveChange: (newActive) => {
+      setActive(newActive);
+    }
+  });
+}

package/dist/lib/MiaodaInspector/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "MiaodaInspector", {
+  enumerable: true,
+  get: function() {
+    return _MiaodaInspector.MiaodaInspector;
+  }
+});
+const _MiaodaInspector = require("./MiaodaInspector");