@pisell/materials 1.8.18 → 1.8.19

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

@@ -0,0 +1,21 @@
+import type { MutableRefObject, PointerEvent as ReactPointerEvent } from 'react';
+import type { FloorMapPaletteDragPayload } from '../utils/floorMapDropUtils';
+export interface UseFloorMapPaletteTouchDragParams {
+    enabled: boolean;
+    mapDropLayerRef: MutableRefObject<HTMLDivElement | null>;
+    contentWidth: number;
+    contentHeight: number;
+    contentOffsetRef: MutableRefObject<{
+        x: number;
+        y: number;
+    }>;
+    setMapPaletteDragActive: (v: boolean) => void;
+    onDropInScene: (payload: FloorMapPaletteDragPayload, sceneX: number, sceneY: number) => void;
+}
+export interface UseFloorMapPaletteTouchDragResult {
+    /** 挂在图元预览按钮上；mouse 不处理，交给 HTML5 DnD */
+    handlePaletteCardPointerDown: (payload: FloorMapPaletteDragPayload, e: ReactPointerEvent<HTMLElement>) => void;
+    /** 图元按钮 onClick 前检查：触摸拖放过则吞掉本次点击 */
+    consumeToolbarClickIfTouchDrag: () => boolean;
+}
+export declare function useFloorMapPaletteTouchDrag(params: UseFloorMapPaletteTouchDragParams): UseFloorMapPaletteTouchDragResult;

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: () => void;
+    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,263 @@
+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 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 (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
+  ]);
+  (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;
+    const wrapper = container.querySelector(".react-transform-wrapper");
+    if (!wrapper) return;
+    const wrapperRect = wrapper.getBoundingClientRect();
+    const nextScale = Math.min(
+      wrapperRect.width / contentWidth,
+      wrapperRect.height / contentHeight,
+      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);
+  }, [contentWidth, contentHeight, zoom.max, transformRef, alignPadSingle]);
+  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,13 @@
+/**
+ * PisellFloorMapLayout 组件入口
+ * 空间布局视图：在二维平面按坐标渲染资源，支持缩放/平移/复位；支持 floorMapConfig + mode 平面图视图
+ */
+export { PisellFloorMapLayout } from './PisellFloorMapLayout';
+export type { PisellFloorMapLayoutProps, PisellFloorMapLayoutRef, FloorMapItemBase, FloorMapItemUnit, FloorMapLayerConfig, FloorMapZoomConfig, FloorMapPanConfig, FloorMapControlsConfig, FloorMapItemShape, FloorMapBackgroundType, FloorMapPanBoundary, FloorMapLayoutMode, FloorMapGridLayoutConfig, FloorMapCanvas, FloorMapElement, FloorMapData, FloorMapViewConfig, FloorMapCanvasUiConfig, FloorMapSceneElement, FloorMapSceneElementDataBinding, FloorMapPlaceMode, FloorMapElementKindCategory, FloorMapElementDataBindingPolicy, FloorMapElementDefaultPresentation, FloorMapEdge, FloorMapElementKindConfig, FloorMapElementType, FloorMapTextSlot, FloorMapDataSources, FloorMapRenderOptions, FloorMapEditPanelParams, DataSourceFormColumn, FloorMapMergedItem, FloorMapRecordFormRenderContext, FloorMapDataSourceRecordFormContent, FloorMapFullscreenMode, FloorMapLayoutContextValue, } from './types';
+export { FLOOR_MAP_STAGE_ELEMENT_KIND, FLOOR_MAP_IMAGE_ELEMENT_KIND, } from './types';
+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,58 @@
+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,
+  mergeFloorMapLayoutPropsFromContext: () => import_mergeFloorMapLayoutContext.mergeFloorMapLayoutPropsFromContext,
+  renderFigmaStyleRoundTableCard: () => import_FigmaTableCard.renderFigmaStyleRoundTableCard,
+  renderFigmaStyleTableCard: () => import_FigmaTableCard.renderFigmaStyleTableCard,
+  useFloorMapLayoutContext: () => import_FloorMapLayoutContext.useFloorMapLayoutContext
+});
+module.exports = __toCommonJS(pisellFloorMapLayout_exports);
+var import_PisellFloorMapLayout = require("./PisellFloorMapLayout");
+var import_types = require("./types");
+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,
+  mergeFloorMapLayoutPropsFromContext,
+  renderFigmaStyleRoundTableCard,
+  renderFigmaStyleTableCard,
+  useFloorMapLayoutContext
+});