@pisell/materials 6.11.17 → 6.11.18

package/lib/components/pisellFloorMapLayout/hooks/useFloorMapPaletteTouchDrag.js

@@ -0,0 +1,146 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/pisellFloorMapLayout/hooks/useFloorMapPaletteTouchDrag.ts
+var useFloorMapPaletteTouchDrag_exports = {};
+__export(useFloorMapPaletteTouchDrag_exports, {
+  useFloorMapPaletteTouchDrag: () => useFloorMapPaletteTouchDrag
+});
+module.exports = __toCommonJS(useFloorMapPaletteTouchDrag_exports);
+var import_react = require("react");
+var import_floorMapDropUtils = require("../utils/floorMapDropUtils");
+var DRAG_THRESHOLD_PX = 8;
+var POINTER_MOVE_OPTS = {
+  capture: true,
+  passive: false
+};
+function useFloorMapPaletteTouchDrag(params) {
+  const {
+    enabled,
+    mapDropLayerRef,
+    contentWidth,
+    contentHeight,
+    contentOffsetRef,
+    setMapPaletteDragActive,
+    onDropInScene
+  } = params;
+  const metricsRef = (0, import_react.useRef)({ cw: contentWidth, ch: contentHeight });
+  metricsRef.current = { cw: contentWidth, ch: contentHeight };
+  const sessionRef = (0, import_react.useRef)(null);
+  const dragActivatedRef = (0, import_react.useRef)(false);
+  const suppressNextClickRef = (0, import_react.useRef)(false);
+  const removeListenersRef = (0, import_react.useRef)(null);
+  const cleanupWindowListeners = (0, import_react.useCallback)(() => {
+    var _a;
+    (_a = removeListenersRef.current) == null ? void 0 : _a.call(removeListenersRef);
+    removeListenersRef.current = null;
+  }, []);
+  (0, import_react.useEffect)(
+    () => () => {
+      cleanupWindowListeners();
+      sessionRef.current = null;
+      dragActivatedRef.current = false;
+      setMapPaletteDragActive(false);
+    },
+    [cleanupWindowListeners, setMapPaletteDragActive]
+  );
+  const handlePaletteCardPointerDown = (0, import_react.useCallback)(
+    (payload, e) => {
+      if (!enabled) return;
+      if (e.pointerType === "mouse") return;
+      if (e.button !== 0) return;
+      cleanupWindowListeners();
+      dragActivatedRef.current = false;
+      sessionRef.current = {
+        payload,
+        pointerId: e.pointerId,
+        startX: e.clientX,
+        startY: e.clientY
+      };
+      const onMove = (ev) => {
+        const s = sessionRef.current;
+        if (!s || ev.pointerId !== s.pointerId) return;
+        const dx = ev.clientX - s.startX;
+        const dy = ev.clientY - s.startY;
+        if (!dragActivatedRef.current && dx * dx + dy * dy >= DRAG_THRESHOLD_PX ** 2) {
+          dragActivatedRef.current = true;
+          setMapPaletteDragActive(true);
+        }
+        if (dragActivatedRef.current && ev.cancelable) {
+          ev.preventDefault();
+        }
+      };
+      const onUp = (ev) => {
+        const s = sessionRef.current;
+        if (!s || ev.pointerId !== s.pointerId) return;
+        cleanupWindowListeners();
+        sessionRef.current = null;
+        const wasDrag = dragActivatedRef.current;
+        dragActivatedRef.current = false;
+        setMapPaletteDragActive(false);
+        if (!wasDrag) return;
+        suppressNextClickRef.current = true;
+        const layer = mapDropLayerRef.current;
+        if (!layer) return;
+        const r = layer.getBoundingClientRect();
+        const { cw, ch } = metricsRef.current;
+        if (cw <= 0 || ch <= 0) return;
+        if (ev.clientX < r.left || ev.clientX > r.right || ev.clientY < r.top || ev.clientY > r.bottom) {
+          return;
+        }
+        const lx = (ev.clientX - r.left) / Math.max(r.width, 1) * cw;
+        const ly = (ev.clientY - r.top) / Math.max(r.height, 1) * ch;
+        const { x, y } = (0, import_floorMapDropUtils.sceneXYFromContentDropOffset)(
+          lx,
+          ly,
+          contentOffsetRef.current
+        );
+        onDropInScene(s.payload, x, y);
+      };
+      window.addEventListener("pointermove", onMove, POINTER_MOVE_OPTS);
+      window.addEventListener("pointerup", onUp, { capture: true });
+      window.addEventListener("pointercancel", onUp, { capture: true });
+      removeListenersRef.current = () => {
+        window.removeEventListener("pointermove", onMove, POINTER_MOVE_OPTS);
+        window.removeEventListener("pointerup", onUp, { capture: true });
+        window.removeEventListener("pointercancel", onUp, { capture: true });
+      };
+    },
+    [
+      enabled,
+      mapDropLayerRef,
+      contentOffsetRef,
+      setMapPaletteDragActive,
+      onDropInScene,
+      cleanupWindowListeners
+    ]
+  );
+  const consumeToolbarClickIfTouchDrag = (0, import_react.useCallback)(() => {
+    if (!suppressNextClickRef.current) return false;
+    suppressNextClickRef.current = false;
+    return true;
+  }, []);
+  return {
+    handlePaletteCardPointerDown,
+    consumeToolbarClickIfTouchDrag
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFloorMapPaletteTouchDrag
+});

package/lib/components/pisellFloorMapLayout/hooks/useFloorMapTransformMetrics.d.ts

@@ -0,0 +1,67 @@
+import type { MutableRefObject } from 'react';
+import type { FloorMapItemBase, FloorMapItemUnit, FloorMapZoomConfig } from '../types';
+/** react-zoom-pan-pinch TransformWrapper render 注入的上下文 */
+export declare type FloorMapTransformContext = {
+    zoomIn: () => void;
+    zoomOut: () => void;
+    resetTransform: () => void;
+    setTransform: (x: number, y: number, scale: number) => void;
+} | null;
+export interface UseFloorMapTransformMetricsParams<T extends FloorMapItemBase> {
+    items: T[];
+    cellSize: number;
+    itemGap: number;
+    effectiveItemUnit: FloorMapItemUnit;
+    isFloorMapView: boolean;
+    mode: 'read' | 'edit';
+    zoom: FloorMapZoomConfig;
+    transformRef: MutableRefObject<FloorMapTransformContext>;
+    /** 由父组件创建并传入 useFloorMapEditState，本 hook 每帧写入内容区偏移 */
+    contentOffsetRef: MutableRefObject<{
+        x: number;
+        y: number;
+    }>;
+    /** 与 mapLayer.boundingPadding 一致；未传用 DEFAULT_BOUNDING_PADDING */
+    boundingPadding?: number;
+    /**
+     * 平面图：当前画布 id（或其它在切换画布时应重置平移/对齐会话的 key）。
+     * 不传则不跑「异步加载图元后的首次左上对齐」逻辑。
+     */
+    frameResetKey?: string;
+}
+export declare function useFloorMapTransformMetrics<T extends FloorMapItemBase>(params: UseFloorMapTransformMetricsParams<T>): {
+    containerRef: import("react").RefObject<HTMLDivElement>;
+    mapAreaRef: import("react").RefObject<HTMLDivElement>;
+    viewportSize: {
+        width: number;
+        height: number;
+    };
+    mapAreaSize: {
+        width: number;
+        height: number;
+    };
+    contentWidth: number;
+    contentHeight: number;
+    contentOffsetX: number;
+    contentOffsetY: number;
+    initialPositionX: number;
+    initialPositionY: number;
+    zoomConfig: {
+        initialScale: number;
+        minScale: number;
+        maxScale: number;
+        step: number;
+    };
+    scale: number;
+    setScale: import("react").Dispatch<import("react").SetStateAction<number>>;
+    isFullscreen: boolean;
+    toggleFullscreen: () => void;
+    fitBounds: () => boolean;
+    lastTransformRef: MutableRefObject<{
+        x: number;
+        y: number;
+        scale: number;
+    }>;
+    isInteractingWithElement: boolean;
+    setIsInteractingWithElement: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};

package/lib/components/pisellFloorMapLayout/hooks/useFloorMapTransformMetrics.js

@@ -0,0 +1,382 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/pisellFloorMapLayout/hooks/useFloorMapTransformMetrics.ts
+var useFloorMapTransformMetrics_exports = {};
+__export(useFloorMapTransformMetrics_exports, {
+  useFloorMapTransformMetrics: () => useFloorMapTransformMetrics
+});
+module.exports = __toCommonJS(useFloorMapTransformMetrics_exports);
+var import_react = require("react");
+var import_layoutMeasurements = require("../utils/layoutMeasurements");
+var DEFAULT_BOUNDING_PADDING = 56;
+var VIEWPORT_TOP_LEFT_MARGIN = 16;
+function useFloorMapTransformMetrics(params) {
+  const {
+    items,
+    cellSize,
+    itemGap,
+    effectiveItemUnit,
+    isFloorMapView,
+    mode,
+    zoom,
+    transformRef,
+    contentOffsetRef,
+    boundingPadding: boundingPaddingProp,
+    frameResetKey
+  } = params;
+  const padSingle = boundingPaddingProp ?? DEFAULT_BOUNDING_PADDING;
+  const containerRef = (0, import_react.useRef)(null);
+  const mapAreaRef = (0, import_react.useRef)(null);
+  const [viewportSize, setViewportSize] = (0, import_react.useState)({ width: 0, height: 0 });
+  (0, import_react.useEffect)(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const ro = new ResizeObserver(() => {
+      setViewportSize({ width: el.clientWidth, height: el.clientHeight });
+    });
+    ro.observe(el);
+    setViewportSize({ width: el.clientWidth, height: el.clientHeight });
+    return () => ro.disconnect();
+  }, []);
+  const [mapAreaSize, setMapAreaSize] = (0, import_react.useState)({ width: 0, height: 0 });
+  (0, import_react.useEffect)(() => {
+    const el = mapAreaRef.current;
+    if (!el) return;
+    const ro = new ResizeObserver(() => {
+      setMapAreaSize({ width: el.clientWidth, height: el.clientHeight });
+    });
+    ro.observe(el);
+    setMapAreaSize({ width: el.clientWidth, height: el.clientHeight });
+    return () => ro.disconnect();
+  }, []);
+  const autoFitOnMount = zoom.autoFitOnMount !== false;
+  const zoomConfig = (0, import_react.useMemo)(
+    () => ({
+      initialScale: zoom.defaultScale ?? 1,
+      minScale: zoom.min ?? 0.5,
+      maxScale: zoom.max ?? 2,
+      step: zoom.step ?? 0.1
+    }),
+    [zoom.defaultScale, zoom.min, zoom.max, zoom.step]
+  );
+  const [scale, setScale] = (0, import_react.useState)(zoomConfig.initialScale);
+  const [isFullscreen, setIsFullscreen] = (0, import_react.useState)(false);
+  const {
+    contentWidth,
+    contentHeight,
+    contentOffsetX,
+    contentOffsetY,
+    alignPadSingle
+  } = (0, import_react.useMemo)(() => {
+    const fromItems = (0, import_layoutMeasurements.getContentSize)(
+      items,
+      cellSize,
+      itemGap,
+      effectiveItemUnit
+    );
+    const pad = padSingle * 2;
+    const zeroOffset = { contentOffsetX: 0, contentOffsetY: 0 };
+    const useBoundingBox = isFloorMapView && effectiveItemUnit === "pixel" && items.length > 0;
+    const box = useBoundingBox ? (0, import_layoutMeasurements.getPixelBoundingBox)(items, cellSize) : null;
+    let padded;
+    let alignPad = null;
+    if (box) {
+      const w = box.maxRight - box.minLeft + pad;
+      const h = box.maxBottom - box.minTop + pad;
+      padded = {
+        contentWidth: w,
+        contentHeight: h,
+        contentOffsetX: padSingle - box.minLeft,
+        contentOffsetY: padSingle - box.minTop
+      };
+      alignPad = padSingle;
+    } else {
+      padded = {
+        contentWidth: fromItems.contentWidth + pad,
+        contentHeight: fromItems.contentHeight + pad,
+        ...zeroOffset
+      };
+    }
+    let result = { ...padded, alignPadSingle: alignPad };
+    if (!isFloorMapView || mode !== "edit") return result;
+    const vw = mapAreaSize.width > 0 ? mapAreaSize.width : viewportSize.width;
+    const vh = mapAreaSize.height > 0 ? mapAreaSize.height : viewportSize.height;
+    if (vw <= 0 || vh <= 0) return result;
+    result = {
+      ...result,
+      contentWidth: Math.max(padded.contentWidth, vw),
+      contentHeight: Math.max(padded.contentHeight, vh)
+    };
+    return result;
+  }, [
+    items,
+    cellSize,
+    itemGap,
+    effectiveItemUnit,
+    isFloorMapView,
+    mode,
+    mapAreaSize.width,
+    mapAreaSize.height,
+    viewportSize.width,
+    viewportSize.height,
+    padSingle
+  ]);
+  const padForAlign = alignPadSingle ?? 0;
+  const initialPositionX = VIEWPORT_TOP_LEFT_MARGIN - padForAlign * zoomConfig.initialScale;
+  const initialPositionY = VIEWPORT_TOP_LEFT_MARGIN - padForAlign * zoomConfig.initialScale;
+  contentOffsetRef.current = { x: contentOffsetX, y: contentOffsetY };
+  const initialAlignRef = (0, import_react.useRef)({
+    frame: "",
+    done: false
+  });
+  (0, import_react.useEffect)(() => {
+    if (!isFloorMapView || frameResetKey === void 0) return;
+    if (initialAlignRef.current.frame !== frameResetKey) {
+      initialAlignRef.current = { frame: frameResetKey, done: false };
+    }
+    if (autoFitOnMount) {
+      initialAlignRef.current.done = true;
+      return;
+    }
+    if (alignPadSingle == null) {
+      initialAlignRef.current.done = false;
+      return;
+    }
+    if (initialAlignRef.current.done) return;
+    let cancelled = false;
+    let raf = 0;
+    const tick = () => {
+      if (cancelled) return;
+      const ctx = transformRef.current;
+      if (!ctx) {
+        raf = requestAnimationFrame(tick);
+        return;
+      }
+      ctx.setTransform(
+        initialPositionX,
+        initialPositionY,
+        zoomConfig.initialScale
+      );
+      initialAlignRef.current.done = true;
+    };
+    raf = requestAnimationFrame(tick);
+    return () => {
+      cancelled = true;
+      cancelAnimationFrame(raf);
+    };
+  }, [
+    isFloorMapView,
+    frameResetKey,
+    alignPadSingle,
+    initialPositionX,
+    initialPositionY,
+    zoomConfig.initialScale,
+    transformRef,
+    autoFitOnMount
+  ]);
+  (0, import_react.useEffect)(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const onFullscreenChange = () => setIsFullscreen(document.fullscreenElement === el);
+    document.addEventListener("fullscreenchange", onFullscreenChange);
+    return () => document.removeEventListener("fullscreenchange", onFullscreenChange);
+  }, []);
+  const toggleFullscreen = (0, import_react.useCallback)(() => {
+    var _a, _b;
+    const el = containerRef.current;
+    if (!el) return;
+    if (document.fullscreenElement) {
+      (_a = document.exitFullscreen) == null ? void 0 : _a.call(document);
+    } else {
+      (_b = el.requestFullscreen) == null ? void 0 : _b.call(el);
+    }
+  }, []);
+  const fitBounds = (0, import_react.useCallback)(() => {
+    const ctx = transformRef.current;
+    const container = containerRef.current;
+    if (!ctx || !container) return false;
+    const wrapper = container.querySelector(".react-transform-wrapper");
+    if (!wrapper) return false;
+    const wrapperRect = wrapper.getBoundingClientRect();
+    if (wrapperRect.width <= 0 || wrapperRect.height <= 0) return false;
+    const pixelBox = isFloorMapView && effectiveItemUnit === "pixel" && items.length > 0 ? (0, import_layoutMeasurements.getPixelBoundingBox)(items, cellSize) : null;
+    if (pixelBox) {
+      const bw = Math.max(1, pixelBox.maxRight - pixelBox.minLeft);
+      const bh = Math.max(1, pixelBox.maxBottom - pixelBox.minTop);
+      const edgePx = 0;
+      const availW = Math.max(1, wrapperRect.width - 2 * edgePx);
+      const availH = Math.max(1, wrapperRect.height - 2 * edgePx);
+      const raw2 = Math.min(availW / bw, availH / bh);
+      const nextScale2 = Math.min(raw2, zoom.max ?? 2);
+      const ap = alignPadSingle ?? padSingle;
+      const bboxCx = ap + bw / 2;
+      const bboxCy = ap + bh / 2;
+      const x2 = wrapperRect.width / 2 - bboxCx * nextScale2;
+      const y2 = wrapperRect.height / 2 - bboxCy * nextScale2;
+      ctx.setTransform(x2, y2, nextScale2);
+      return true;
+    }
+    if (contentWidth <= 0 || contentHeight <= 0) return false;
+    const raw = Math.min(
+      wrapperRect.width / contentWidth,
+      wrapperRect.height / contentHeight
+    );
+    const nextScale = Math.min(raw, zoom.max ?? 2);
+    const padA = alignPadSingle ?? 0;
+    const x = VIEWPORT_TOP_LEFT_MARGIN - padA * nextScale;
+    const y = VIEWPORT_TOP_LEFT_MARGIN - padA * nextScale;
+    ctx.setTransform(x, y, nextScale);
+    return true;
+  }, [
+    contentWidth,
+    contentHeight,
+    zoom.max,
+    transformRef,
+    alignPadSingle,
+    isFloorMapView,
+    effectiveItemUnit,
+    items,
+    cellSize,
+    padSingle
+  ]);
+  const autoFitOnceRef = (0, import_react.useRef)({
+    frame: "",
+    done: false
+  });
+  const prevItemsCountForAutoFitRef = (0, import_react.useRef)(null);
+  (0, import_react.useLayoutEffect)(() => {
+    if (!isFloorMapView || !autoFitOnMount || frameResetKey === void 0) return;
+    const frame = String(frameResetKey);
+    if (autoFitOnceRef.current.frame !== frame) {
+      autoFitOnceRef.current = { frame, done: false };
+      prevItemsCountForAutoFitRef.current = null;
+    }
+    const itemCount = items.length;
+    const prevN = prevItemsCountForAutoFitRef.current;
+    if (prevN !== null && prevN === 0 && itemCount > 0) {
+      autoFitOnceRef.current.done = false;
+    }
+    prevItemsCountForAutoFitRef.current = itemCount;
+    if (autoFitOnceRef.current.done) return;
+    if (effectiveItemUnit === "pixel" && itemCount === 0) {
+      return;
+    }
+    if (contentWidth <= 0 || contentHeight <= 0) return;
+    let cancelled = false;
+    let raf = 0;
+    let attempts = 0;
+    const MAX_AUTO_FIT_ATTEMPTS = 160;
+    const tick = () => {
+      if (cancelled) return;
+      if (attempts >= MAX_AUTO_FIT_ATTEMPTS) return;
+      const ctx = transformRef.current;
+      const container = containerRef.current;
+      const wrapper = container == null ? void 0 : container.querySelector(
+        ".react-transform-wrapper"
+      );
+      if (!ctx || !wrapper) {
+        attempts += 1;
+        raf = requestAnimationFrame(tick);
+        return;
+      }
+      const rect = wrapper.getBoundingClientRect();
+      if (rect.width <= 0 || rect.height <= 0) {
+        attempts += 1;
+        raf = requestAnimationFrame(tick);
+        return;
+      }
+      raf = requestAnimationFrame(() => {
+        if (cancelled) return;
+        raf = requestAnimationFrame(() => {
+          if (cancelled) return;
+          const ok = fitBounds();
+          if (ok) {
+            autoFitOnceRef.current.done = true;
+            return;
+          }
+          attempts += 1;
+          if (attempts < MAX_AUTO_FIT_ATTEMPTS) {
+            raf = requestAnimationFrame(tick);
+          }
+        });
+      });
+    };
+    raf = requestAnimationFrame(tick);
+    return () => {
+      cancelled = true;
+      cancelAnimationFrame(raf);
+    };
+  }, [
+    isFloorMapView,
+    autoFitOnMount,
+    frameResetKey,
+    effectiveItemUnit,
+    items.length,
+    contentWidth,
+    contentHeight,
+    viewportSize.width,
+    viewportSize.height,
+    mapAreaSize.width,
+    mapAreaSize.height,
+    fitBounds,
+    transformRef
+  ]);
+  const lastTransformRef = (0, import_react.useRef)({ x: 0, y: 0, scale: 1 });
+  const [isInteractingWithElement, setIsInteractingWithElement] = (0, import_react.useState)(false);
+  const prevInteractingRef = (0, import_react.useRef)(false);
+  (0, import_react.useEffect)(() => {
+    if (isInteractingWithElement) {
+      prevInteractingRef.current = true;
+      return;
+    }
+    if (!prevInteractingRef.current) return;
+    prevInteractingRef.current = false;
+    const saved = lastTransformRef.current;
+    const raf = requestAnimationFrame(() => {
+      var _a;
+      (_a = transformRef.current) == null ? void 0 : _a.setTransform(saved.x, saved.y, saved.scale);
+    });
+    return () => cancelAnimationFrame(raf);
+  }, [isInteractingWithElement, transformRef]);
+  return {
+    containerRef,
+    mapAreaRef,
+    viewportSize,
+    mapAreaSize,
+    contentWidth,
+    contentHeight,
+    contentOffsetX,
+    contentOffsetY,
+    initialPositionX,
+    initialPositionY,
+    zoomConfig,
+    scale,
+    setScale,
+    isFullscreen,
+    toggleFullscreen,
+    fitBounds,
+    lastTransformRef,
+    isInteractingWithElement,
+    setIsInteractingWithElement
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFloorMapTransformMetrics
+});

package/lib/components/pisellFloorMapLayout/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * PisellFloorMapLayout 组件入口
+ * 空间布局视图：在二维平面按坐标渲染资源，支持缩放/平移/复位；支持 floorMapConfig + mode 平面图视图
+ */
+export { PisellFloorMapLayout } from './PisellFloorMapLayout';
+export type { PisellFloorMapLayoutProps, PisellFloorMapLayoutRef, FloorMapItemBase, FloorMapItemUnit, FloorMapLayerConfig, FloorMapZoomConfig, FloorMapPanConfig, FloorMapControlsConfig, FloorMapItemShape, FloorMapBackgroundType, FloorMapPanBoundary, FloorMapLayoutMode, FloorMapGridLayoutConfig, FloorMapCanvas, FloorMapCanvasNameI18n, FloorMapElement, FloorMapData, FloorMapViewConfig, FloorMapCanvasUiConfig, FloorMapSceneElement, FloorMapSceneElementDataBinding, FloorMapPlaceMode, FloorMapElementKindCategory, FloorMapElementDataBindingPolicy, FloorMapElementDefaultPresentation, FloorMapEdge, FloorMapElementKindConfig, FloorMapElementType, FloorMapTextSlot, FloorMapDataSources, FloorMapRenderOptions, FloorMapEditPanelParams, DataSourceFormColumn, FloorMapMergedItem, FloorMapRecordFormRenderContext, FloorMapDataSourceRecordFormContent, FloorMapFullscreenMode, FloorMapLayoutContextValue, FloorMapViewportOverlayRenderArgs, } from './types';
+export { FLOOR_MAP_STAGE_ELEMENT_KIND, FLOOR_MAP_IMAGE_ELEMENT_KIND, } from './types';
+export { renderFloorMapFallbackPlaceholder } from './utils/floorMapFallbackRender';
+export { isFloorMapImageElementKind } from './utils/floorMapElementKindUtils';
+export { FloorMapLayoutProvider, useFloorMapLayoutContext, EMPTY_FLOOR_MAP_LAYOUT_CONTEXT, } from './context/FloorMapLayoutContext';
+export type { FloorMapLayoutProviderProps } from './context/FloorMapLayoutContext';
+export { mergeFloorMapLayoutPropsFromContext } from './context/mergeFloorMapLayoutContext';
+export { FloorMapImageElement } from './components/FloorMapImageElement';
+export { getFigmaTableCardFromMerged, renderFigmaStyleTableCard, renderFigmaStyleRoundTableCard, getRenderItemByKindTable, getRenderItemByKindRoundTable, } from './components/FigmaTableCard';
+export type { FigmaTableCardItem, FigmaTableStatus, } from './components/FigmaTableCard';

package/lib/components/pisellFloorMapLayout/index.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/components/pisellFloorMapLayout/index.tsx
+var pisellFloorMapLayout_exports = {};
+__export(pisellFloorMapLayout_exports, {
+  EMPTY_FLOOR_MAP_LAYOUT_CONTEXT: () => import_FloorMapLayoutContext.EMPTY_FLOOR_MAP_LAYOUT_CONTEXT,
+  FLOOR_MAP_IMAGE_ELEMENT_KIND: () => import_types.FLOOR_MAP_IMAGE_ELEMENT_KIND,
+  FLOOR_MAP_STAGE_ELEMENT_KIND: () => import_types.FLOOR_MAP_STAGE_ELEMENT_KIND,
+  FloorMapImageElement: () => import_FloorMapImageElement.FloorMapImageElement,
+  FloorMapLayoutProvider: () => import_FloorMapLayoutContext.FloorMapLayoutProvider,
+  PisellFloorMapLayout: () => import_PisellFloorMapLayout.PisellFloorMapLayout,
+  getFigmaTableCardFromMerged: () => import_FigmaTableCard.getFigmaTableCardFromMerged,
+  getRenderItemByKindRoundTable: () => import_FigmaTableCard.getRenderItemByKindRoundTable,
+  getRenderItemByKindTable: () => import_FigmaTableCard.getRenderItemByKindTable,
+  isFloorMapImageElementKind: () => import_floorMapElementKindUtils.isFloorMapImageElementKind,
+  mergeFloorMapLayoutPropsFromContext: () => import_mergeFloorMapLayoutContext.mergeFloorMapLayoutPropsFromContext,
+  renderFigmaStyleRoundTableCard: () => import_FigmaTableCard.renderFigmaStyleRoundTableCard,
+  renderFigmaStyleTableCard: () => import_FigmaTableCard.renderFigmaStyleTableCard,
+  renderFloorMapFallbackPlaceholder: () => import_floorMapFallbackRender.renderFloorMapFallbackPlaceholder,
+  useFloorMapLayoutContext: () => import_FloorMapLayoutContext.useFloorMapLayoutContext
+});
+module.exports = __toCommonJS(pisellFloorMapLayout_exports);
+var import_PisellFloorMapLayout = require("./PisellFloorMapLayout");
+var import_types = require("./types");
+var import_floorMapFallbackRender = require("./utils/floorMapFallbackRender");
+var import_floorMapElementKindUtils = require("./utils/floorMapElementKindUtils");
+var import_FloorMapLayoutContext = require("./context/FloorMapLayoutContext");
+var import_mergeFloorMapLayoutContext = require("./context/mergeFloorMapLayoutContext");
+var import_FloorMapImageElement = require("./components/FloorMapImageElement");
+var import_FigmaTableCard = require("./components/FigmaTableCard");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EMPTY_FLOOR_MAP_LAYOUT_CONTEXT,
+  FLOOR_MAP_IMAGE_ELEMENT_KIND,
+  FLOOR_MAP_STAGE_ELEMENT_KIND,
+  FloorMapImageElement,
+  FloorMapLayoutProvider,
+  PisellFloorMapLayout,
+  getFigmaTableCardFromMerged,
+  getRenderItemByKindRoundTable,
+  getRenderItemByKindTable,
+  isFloorMapImageElementKind,
+  mergeFloorMapLayoutPropsFromContext,
+  renderFigmaStyleRoundTableCard,
+  renderFigmaStyleTableCard,
+  renderFloorMapFallbackPlaceholder,
+  useFloorMapLayoutContext
+});