m2mui-calendar-timeline 2.1.1 → 2.2.0

package/{dist/CalendarTimeline.d.ts → CalendarTimeline.d.ts}

@@ -1,145 +1,142 @@
-/** @jsx jsx */
-import { CTClickCellCallback, CTDragItemCallback, CTDraggingProps, CTGroup, CTItem, CTItemProps, CTRenderDate, CTRenderGroup, CTRenderItem, CTResizeItemCallback, CTScrollCallback } from "./types";
-import { CellProps } from "./Cell";
-import React from "react";
-export interface CTCellProps extends CellProps {
-}
-export declare type CTRenderCell = (props: CTCellProps) => JSX.Element;
-export interface CalendarTimelineProps {
-    /**
-     * Cellをどのように描画するかを指定します。
-     * CellProps.dataからgroupsや日付の情報が取れるので自前でContextなどを用意する必要はありません。
-     * 注意：CellProps.styleを必ずコンポーネントに渡してください。
-     */
-    renderCell?: CTRenderCell;
-    /**
-     * @deprecated
-     * Use CalendarTimelineProps.renderCell instead.
-     *
-     * Cellがクリックされたときに呼ばれます。クリックされたCellを特定できる情報を返します。
-     */
-    onClickCell?: CTClickCellCallback;
-    /**
-     * 表示できる日付の範囲を指定します。
-     * @param activeMonthCount 有効な月数を指定します。指定がない場合、24になります。ここで指定された値は調整済みのdateを中心に両側に均等に割り振られます。つまり24の場合、去年と来年の同日まで閲覧できるようになります。
-     * @param start 有効範囲の最小値となる日付を指定します。activeMonthCountがある場合、設定できません。
-     * @param end 有効範囲の最大値となる日付を指定します。startと同様に日付の調整は行われません。activeMonthCountがある場合、設定できません。
-     * @param date Dateまたは日付を表すstringを指定してください。
-     * 【activeMonthCountが設定されている場合】：指定がない場合、new Date()相当の値が入ります。dateの指定した日付が最初から画面付近に入るように自動で1日または15日調整されます。
-     * 【activeMonthCountが設定されていない場合】：指定がない場合、startと同じ値が入ります。パターン1とは異なり、日付の調整が行われません。
-     */
-    visibleDates?: {
-        /**
-         * 基礎となる日付です。
-         * @default "new Date()"
-         */
-        date?: Date | string;
-        /**
-         * 表示できる月数。現在の想定では中心となる日付から左右に均等に割り振られます。
-         * @default 24
-         */
-        activeMonthCount?: number;
-        start?: never;
-        end?: never;
-    } | {
-        /**
-         * 開始日
-         * @format "YYYY-MM-DD"
-         */
-        start: Date | string;
-        /**
-         * 終了日
-         * @format "YYYY-MM-DD"
-         */
-        end: Date | string;
-        /**
-         * 基礎となる日付です。
-         */
-        date?: Date | string;
-        activeMonthCount?: never;
-    };
-    /**
-     * 左上に表示される文字列です。
-     */
-    title?: string | (() => JSX.Element);
-    /**
-     * 縦方向の項目名に使用され、左側に表示されます。
-     * @param title 任意の文字列を渡します
-     * @param id 任意の文字列または数値。ここで指定したidはitems及びgroupコンポーネントのkeyとして利用されるため、ユニークである必要があります。
-     */
-    groups: CTGroup[];
-    /**
-     * groupsで渡された値をどのように描画するかを指定します。groupsで指定したものに加えて、styleが渡されます。
-     */
-    renderGroup?: CTRenderGroup;
-    /**
-     * 予約などのイベントを表示するためコンポーネントに使用される値を配列で渡します。
-     * @param title 任意の文字列を渡します。
-     * @param start 開始日 Dateで時刻を考慮する必要があります。
-     * @param end 終了日 Dateで時刻を考慮する必要があります。
-     * @param group groupsで指定されたidを指定します。該当するgroupの行に配置されます。
-     * @param draggingProps dragAxisでドラッグ方向、disabledでドラッグ可能にするかどうかを指摘できます。
-     * @param itemProps 任意のHTMLPropsをItemに渡すことができます。
-     */
-    items: CTItem[];
-    /**
-     * itemsで渡された値をどのように描画するかを指定します。
-     * @param rowIndex 行番号。groups[rowIndex]で該当するgroupを取得できます。
-     * @param columnIndex 列番号。用途はほぼないと思います。
-     * @param itemIndex アイテム番号。items[itemIndex]で該当するitemを取得できます。
-     * @param title itemsで渡されたtitleです。
-     */
-    renderItem?: CTRenderItem;
-    /**
-     * itemのドラッグ操作が完了されたときに呼ばれます。
-     */
-    onDragItem?: CTDragItemCallback;
-    /**
-     * 列番号として使用される日付などの情報をどのように描画するかを指定します。
-     * @param date Date。移動先の日付です。時間情報は持っていません。
-     * @param style CSSProperties。必ず渡してください。
-     */
-    renderDate?: CTRenderDate;
-    /**
-     * 横方向にスクロールした際、先頭の日付を返します。
-     * 月や年より下の情報がいらない場合は適切に比較処理を行い、無駄な処理が行われないように注意してください。
-     */
-    onScroll?: CTScrollCallback;
-    /**
-     * itemのリサイズ操作が完了されたときに呼ばれます。
-     */
-    onResizeItem?: CTResizeItemCallback;
-    /**
-     * 余分に描画される列数を指定します。指定された列数をまたぐItemが存在する場合、位置によっては描画されない場合があります。
-     * @default 10
-     */
-    overscanColumnCount?: number;
-    /**
-     * 余分に描画される行数を指定します。指定された行数をまたぐItemが存在する場合、位置によっては描画されない場合があります。
-     * @default 10
-     */
-    overscanRowCount?: number;
-    /**
-     * 全てのアイテムのドラッグ方法を一括で指定できます。items propで個別にdraggingPropsで指定を行った場合、重複するものは上書きされます。
-     */
-    draggingProps?: CTDraggingProps;
-    /**
-     * 表示される行数を指定します。CalendarTimelineの高さはcellHeight * visibleRowCount + dateHeightで決定されます。
-     * @default 20
-     */
-    visibleRowCount?: number;
-    /**
-     * 表示される列数を指定します。CalendarTimelineの幅はcellWidth * visibleColumnCount + groupWidthで決定されます。
-     * @default 20
-     */
-    visibleColumnCount?: number;
-    /**
-     * 全てのアイテムに渡す任意のPropsを一括で指定できます。items propで個別にitemPropsで指定を行った場合、重複するものは上書きされます。
-     */
-    itemProps?: CTItemProps;
-    groupWidth?: number;
-    cellWidth?: number;
-    cellHeight?: number;
-    dateHeight?: number;
-}
-export declare const CalendarTimeline: React.FC<CalendarTimelineProps>;
+import { CTClickCellCallback, CTDragItemCallback, CTDraggingProps, CTGroup, CTItem, CTItemProps, CTRenderDate, CTRenderGroup, CTRenderItem, CTResizeItemCallback, CTScrollCallback } from "./types";
+import { CellProps } from "./Cell";
+export type CTCellProps = CellProps;
+export type CTRenderCell = (props: CTCellProps) => JSX.Element;
+export interface CalendarTimelineProps {
+    /**
+     * Cellをどのように描画するかを指定します。
+     * CellProps.dataからgroupsや日付の情報が取れるので自前でContextなどを用意する必要はありません。
+     * 注意：CellProps.styleを必ずコンポーネントに渡してください。
+     */
+    renderCell?: CTRenderCell;
+    /**
+     * @deprecated
+     * Use CalendarTimelineProps.renderCell instead.
+     *
+     * Cellがクリックされたときに呼ばれます。クリックされたCellを特定できる情報を返します。
+     */
+    onClickCell?: CTClickCellCallback;
+    /**
+     * 表示できる日付の範囲を指定します。
+     * @param activeMonthCount 有効な月数を指定します。指定がない場合、24になります。ここで指定された値は調整済みのdateを中心に両側に均等に割り振られます。つまり24の場合、去年と来年の同日まで閲覧できるようになります。
+     * @param start 有効範囲の最小値となる日付を指定します。activeMonthCountがある場合、設定できません。
+     * @param end 有効範囲の最大値となる日付を指定します。startと同様に日付の調整は行われません。activeMonthCountがある場合、設定できません。
+     * @param date Dateまたは日付を表すstringを指定してください。
+     * 【activeMonthCountが設定されている場合】：指定がない場合、new Date()相当の値が入ります。dateの指定した日付が最初から画面付近に入るように自動で1日または15日調整されます。
+     * 【activeMonthCountが設定されていない場合】：指定がない場合、startと同じ値が入ります。パターン1とは異なり、日付の調整が行われません。
+     */
+    visibleDates?: {
+        /**
+         * 基礎となる日付です。
+         * @default "new Date()"
+         */
+        date?: Date | string;
+        /**
+         * 表示できる月数。現在の想定では中心となる日付から左右に均等に割り振られます。
+         * @default 24
+         */
+        activeMonthCount?: number;
+        start?: never;
+        end?: never;
+    } | {
+        /**
+         * 開始日
+         * @format "YYYY-MM-DD"
+         */
+        start: Date | string;
+        /**
+         * 終了日
+         * @format "YYYY-MM-DD"
+         */
+        end: Date | string;
+        /**
+         * 基礎となる日付です。
+         */
+        date?: Date | string;
+        activeMonthCount?: never;
+    };
+    /**
+     * 左上に表示される文字列です。
+     */
+    title?: string | (() => JSX.Element);
+    /**
+     * 縦方向の項目名に使用され、左側に表示されます。
+     * @param title 任意の文字列を渡します
+     * @param id 任意の文字列または数値。ここで指定したidはitems及びgroupコンポーネントのkeyとして利用されるため、ユニークである必要があります。
+     */
+    groups?: CTGroup[];
+    /**
+     * groupsで渡された値をどのように描画するかを指定します。groupsで指定したものに加えて、styleが渡されます。
+     */
+    renderGroup?: CTRenderGroup;
+    /**
+     * 予約などのイベントを表示するためコンポーネントに使用される値を配列で渡します。
+     * @param title 任意の文字列を渡します。
+     * @param start 開始日 Dateで時刻を考慮する必要があります。
+     * @param end 終了日 Dateで時刻を考慮する必要があります。
+     * @param group groupsで指定されたidを指定します。該当するgroupの行に配置されます。
+     * @param draggingProps dragAxisでドラッグ方向、disabledでドラッグ可能にするかどうかを指摘できます。
+     * @param itemProps 任意のHTMLPropsをItemに渡すことができます。
+     */
+    items: CTItem[];
+    /**
+     * itemsで渡された値をどのように描画するかを指定します。
+     * @param rowIndex 行番号。groups[rowIndex]で該当するgroupを取得できます。
+     * @param columnIndex 列番号。用途はほぼないと思います。
+     * @param itemIndex アイテム番号。items[itemIndex]で該当するitemを取得できます。
+     * @param title itemsで渡されたtitleです。
+     */
+    renderItem?: CTRenderItem;
+    /**
+     * itemのドラッグ操作が完了されたときに呼ばれます。
+     */
+    onDragItem?: CTDragItemCallback;
+    /**
+     * 列番号として使用される日付などの情報をどのように描画するかを指定します。
+     * @param date Date。移動先の日付です。時間情報は持っていません。
+     * @param style CSSProperties。必ず渡してください。
+     */
+    renderDate?: CTRenderDate;
+    /**
+     * 横方向にスクロールした際、先頭の日付を返します。
+     * 月や年より下の情報がいらない場合は適切に比較処理を行い、無駄な処理が行われないように注意してください。
+     */
+    onScroll?: CTScrollCallback;
+    /**
+     * itemのリサイズ操作が完了されたときに呼ばれます。
+     */
+    onResizeItem?: CTResizeItemCallback;
+    /**
+     * 余分に描画される列数を指定します。指定された列数をまたぐItemが存在する場合、位置によっては描画されない場合があります。
+     * @default 10
+     */
+    overscanColumnCount?: number;
+    /**
+     * 余分に描画される行数を指定します。指定された行数をまたぐItemが存在する場合、位置によっては描画されない場合があります。
+     * @default 10
+     */
+    overscanRowCount?: number;
+    /**
+     * 全てのアイテムのドラッグ方法を一括で指定できます。items propで個別にdraggingPropsで指定を行った場合、重複するものは上書きされます。
+     */
+    draggingProps?: CTDraggingProps;
+    /**
+     * 表示される行数を指定します。CalendarTimelineの高さはcellHeight * visibleRowCount + dateHeightで決定されます。
+     * @default 20
+     */
+    visibleRowCount?: number;
+    /**
+     * 表示される列数を指定します。CalendarTimelineの幅はcellWidth * visibleColumnCount + groupWidthで決定されます。
+     * @default 20
+     */
+    visibleColumnCount?: number;
+    /**
+     * 全てのアイテムに渡す任意のPropsを一括で指定できます。items propで個別にitemPropsで指定を行った場合、重複するものは上書きされます。
+     */
+    itemProps?: CTItemProps;
+    groupWidth?: number;
+    cellWidth?: number;
+    cellHeight?: number;
+    dateHeight?: number;
+}
+export declare const CalendarTimeline: ({ groups: _groups, items, title, onDragItem, renderDate, renderItem, renderGroup, renderCell, overscanColumnCount: defaultOverscanColumnCount, overscanRowCount: defaultOverscanRowCount, onScroll, onResizeItem, cellWidth, cellHeight, groupWidth, dateHeight, draggingProps, itemProps, visibleColumnCount, visibleRowCount, onClickCell, visibleDates, }: CalendarTimelineProps) => import("@emotion/react/jsx-runtime").JSX.Element;

package/CalendarTimeline.js

@@ -0,0 +1,276 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import { CalendarTimelineContext, InnerElement } from "./InnerElement";
+import { Cell as DefaultCell, defaultCellStyles } from "./Cell";
+import { DefaultDate, DefaultGroup, DefaultItem } from "./DefaultComponents";
+import { FixedSizeGrid } from "react-window";
+import { ItemWrapperContext } from "./ItemWrapper";
+import { css } from "@emotion/react";
+import { roundToZero } from "./roundToZero";
+import React, { useCallback, useMemo, useState } from "react";
+import dayjs from "dayjs";
+import { jsx as ___EmotionJSX } from "@emotion/react";
+var Grid = FixedSizeGrid;
+var addDate = (prev, add) => {
+  return dayjs(prev).clone().add(add, "d").set("hour", dayjs(prev).hour()).toDate();
+};
+var dayjsRemovedTime = date => dayjs(dayjs(date).format("YYYYMMDD"));
+export var CalendarTimeline = _ref => {
+  var {
+    groups: _groups,
+    items,
+    title,
+    onDragItem,
+    renderDate = DefaultDate,
+    renderItem = DefaultItem,
+    renderGroup = DefaultGroup,
+    renderCell = DefaultCell,
+    overscanColumnCount: defaultOverscanColumnCount = 10,
+    overscanRowCount: defaultOverscanRowCount = 10,
+    onScroll,
+    onResizeItem,
+    cellWidth = 64,
+    cellHeight = 27,
+    groupWidth = 230,
+    dateHeight = 64,
+    draggingProps,
+    itemProps,
+    visibleColumnCount = 20,
+    visibleRowCount = 20,
+    onClickCell,
+    visibleDates
+  } = _ref;
+  var groups = useMemo(() => {
+    if (_groups && _groups.length > 0) {
+      return _groups;
+    } else {
+      return Array.from({
+        length: visibleRowCount
+      }).map((_, i) => {
+        return {
+          id: "__DUMMY_GROUP_" + i + "__",
+          title: ""
+        };
+      });
+    }
+  }, [_groups, visibleRowCount]);
+  var rowCount = useMemo(() => groups.length, [groups]);
+  var columns = useMemo(() => {
+    if ((visibleDates == null ? void 0 : visibleDates.start) !== undefined) {
+      var length = dayjs(visibleDates.end).diff(visibleDates.start, "day") + 1;
+      var startDate = dayjs(visibleDates.start);
+      return Array.from({
+        length
+      }).map((_, i) => {
+        var date = startDate.clone().add(i, "day");
+        var day = date.date();
+        var weekday = date.day();
+        var month = date.month();
+        var year = date.year();
+        var dateString = date.format("YYYY-MM-DD");
+        return {
+          date: date.toDate(),
+          weekday,
+          day,
+          month,
+          year,
+          dateString
+        };
+      });
+    } else {
+      var _visibleDates$activeM, _visibleDates$date;
+      var activeMonthCount = (_visibleDates$activeM = visibleDates == null ? void 0 : visibleDates.activeMonthCount) != null ? _visibleDates$activeM : 24;
+      var date = (_visibleDates$date = visibleDates == null ? void 0 : visibleDates.date) != null ? _visibleDates$date : new Date();
+      var baseDate = dayjs(dayjs(date).format("YYYYMMDD"));
+      var baseDay = baseDate.date() > 15 ? 14 : 1;
+      var _startDate = baseDate.add(Math.ceil(-activeMonthCount / 2), "month").set("date", baseDay);
+      return Array.from({
+        length: activeMonthCount
+      }).map((_, i) => {
+        var dayOfStartMonth = _startDate.clone().add(i, "month");
+        var daysInMonth = dayOfStartMonth.daysInMonth();
+        return Array.from({
+          length: daysInMonth
+        }).map((_, j) => {
+          var date = dayOfStartMonth.clone().add(j, "day");
+          var day = date.date();
+          var weekday = date.day();
+          var month = date.month();
+          var year = date.year();
+          var dateString = date.format("YYYY-MM-DD");
+          return {
+            date: date.toDate(),
+            weekday,
+            day,
+            month,
+            year,
+            dateString
+          };
+        });
+      }).flat();
+    }
+  }, [visibleDates]);
+  var columnCount = useMemo(() => columns.length, [columns]);
+  var initialScrollLeft = useMemo(() => {
+    if ((visibleDates == null ? void 0 : visibleDates.start) === undefined) {
+      var _visibleDates$activeM2;
+      return ((_visibleDates$activeM2 = visibleDates == null ? void 0 : visibleDates.activeMonthCount) != null ? _visibleDates$activeM2 : 24) % 2 === 0 ? columnCount / 2 * cellWidth : (columnCount / 2 - 15) * cellWidth;
+    }
+    return (visibleDates == null ? void 0 : visibleDates.date) !== undefined ? dayjs(visibleDates.date).diff(visibleDates == null ? void 0 : visibleDates.start, "day") * cellWidth : 0;
+  }, [cellWidth, columnCount, visibleDates]);
+  var [editingCell, setEditingCell] = useState({
+    x: -1,
+    y: -1,
+    lastX: -1,
+    lastY: -1,
+    columnIndex: -1,
+    rowIndex: -1
+  });
+  var [dragging, setDragging] = useState(false);
+  var handleDragStart = useCallback((event, data) => {
+    var columnIndex = parseInt(data.node.dataset.columnIndex, 10);
+    var rowIndex = parseInt(data.node.dataset.rowIndex, 10);
+    data.node.style.filter = "opacity(100%)";
+    data.node.style.zIndex = "1";
+    setEditingCell(_extends({
+      columnIndex,
+      rowIndex
+    }, data));
+    setDragging(true);
+  }, []);
+  var handleDragStop = useCallback((event, data) => {
+    data.node.style.filter = "";
+    data.node.style.zIndex = "0";
+    if (onDragItem) {
+      var _item$draggingProps;
+      var itemIndex = parseInt(data.node.dataset.itemIndex, 10);
+      var item = items[itemIndex];
+      var dragAxis = (draggingProps == null ? void 0 : draggingProps.dragAxis) || ((_item$draggingProps = item.draggingProps) == null ? void 0 : _item$draggingProps.dragAxis);
+      if (dragAxis === undefined) {
+        return;
+      }
+      var prev = _extends({}, editingCell);
+      var x = dragAxis === "y" ? 0 : roundToZero((prev.lastX - data.lastX) / cellWidth);
+      var y = dragAxis === "x" ? 0 : roundToZero((prev.y - data.y) / cellHeight);
+      if (x !== 0 || y !== 0) {
+        var _columns, _groups2;
+        var date = (_columns = columns[prev.columnIndex - x]) == null ? void 0 : _columns.date;
+        var group = (_groups2 = groups[prev.rowIndex - y]) == null ? void 0 : _groups2.id;
+        var diff = dayjs(date).diff(dayjsRemovedTime(item.start), "date");
+        if (date !== undefined && group !== undefined) {
+          var targetItem = _extends({}, item, {
+            group,
+            start: addDate(item.start, diff),
+            end: addDate(item.end, diff)
+          });
+          var copy = items.slice();
+          copy[itemIndex] = targetItem;
+          onDragItem(copy, _extends({}, targetItem, {
+            itemIndex
+          }));
+        }
+      }
+      setDragging(false);
+    }
+  }, [cellHeight, cellWidth, columns, draggingProps, editingCell, groups, items, onDragItem]);
+  var handleResizeStop = useCallback((event, direction, ref, delta) => {
+    if (onResizeItem) {
+      var itemIndex = parseInt(ref.dataset.itemIndex, 10);
+      var copy = items.slice();
+      var item = copy[itemIndex];
+      if (direction === "left") {
+        var start = dayjs(item.start).add(roundToZero(-delta.width / cellWidth), "day").toDate();
+        copy[itemIndex] = _extends({}, item, {
+          start
+        });
+        onResizeItem(copy, {
+          itemIndex,
+          group: item.group,
+          start,
+          end: item.end
+        });
+      } else if (direction === "right") {
+        var end = dayjs(item.end).add(roundToZero(delta.width / cellWidth), "day").toDate();
+        copy[itemIndex] = _extends({}, item, {
+          end
+        });
+        onResizeItem(copy, {
+          itemIndex,
+          group: item.group,
+          start: item.start,
+          end
+        });
+      }
+    }
+  }, [cellWidth, items, onResizeItem]);
+  var handleScroll = useCallback(props => {
+    if (onScroll) {
+      onScroll(columns[roundToZero(props.scrollLeft / cellWidth)].date);
+    }
+  }, [cellWidth, columns, onScroll]);
+  var itemData = useMemo(() => {
+    return {
+      makeHandleClick: onClickCell ? _ref2 => {
+        var {
+          rowIndex,
+          columnIndex
+        } = _ref2;
+        return event => {
+          var group = groups[rowIndex];
+          var column = columns[columnIndex];
+          onClickCell({
+            column,
+            group: _extends({}, group, {
+              index: rowIndex
+            })
+          }, event);
+        };
+      } : undefined,
+      groups,
+      columns,
+      defaultStyles: defaultCellStyles
+    };
+  }, [columns, groups, onClickCell]);
+  return ___EmotionJSX(CalendarTimelineContext.Provider, {
+    value: {
+      columns,
+      items,
+      groups,
+      renderDate,
+      title,
+      editingCell,
+      renderGroup,
+      cellHeight,
+      cellWidth,
+      groupWidth,
+      dateHeight,
+      draggingProps,
+      itemProps
+    }
+  }, ___EmotionJSX(ItemWrapperContext.Provider, {
+    value: {
+      cellHeight,
+      cellWidth,
+      handleDragStart,
+      handleDragStop,
+      handleResizeStop: onResizeItem ? handleResizeStop : undefined,
+      renderItem
+    }
+  }, ___EmotionJSX("div", {
+    css: /*#__PURE__*/css("position:relative;display:flex;flex-direction:row;& .CalendarTimeline__Item{filter:opacity(", dragging ? "50%" : "100%", ");}" + (process.env.NODE_ENV === "production" ? "" : ";label:CalendarTimeline;"), process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/CalendarTimeline.tsx"],"names":[],"mappings":"AAsekB","file":"../../src/CalendarTimeline.tsx","sourcesContent":["import {\n  CTClickCellCallback,\n  CTDragItemCallback,\n  CTDraggingProps,\n  CTGroup,\n  CTItem,\n  CTItemProps,\n  CTRenderDate,\n  CTRenderGroup,\n  CTRenderItem,\n  CTResizeItemCallback,\n  CTScrollCallback,\n} from \"./types\";\nimport { CalendarTimelineContext, InnerElement } from \"./InnerElement\";\nimport { CellProps, Cell as DefaultCell, defaultCellStyles } from \"./Cell\";\nimport { DefaultDate, DefaultGroup, DefaultItem } from \"./DefaultComponents\";\nimport { DraggableData, RndDragCallback, RndResizeCallback } from \"react-rnd\";\nimport {\n  FixedSizeGrid,\n  FixedSizeGridProps,\n  GridOnScrollProps,\n} from \"react-window\";\nimport { ItemWrapperContext } from \"./ItemWrapper\";\nimport { css } from \"@emotion/react\";\nimport { roundToZero } from \"./roundToZero\";\nimport React, { useCallback, useMemo, useState } from \"react\";\nimport dayjs from \"dayjs\";\n\nconst Grid = FixedSizeGrid as unknown as (\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  props: FixedSizeGridProps<any> & {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    children?: any;\n  }\n) => JSX.Element;\nconst addDate = (prev: Date, add: number) => {\n  return dayjs(prev)\n    .clone()\n    .add(add, \"d\")\n    .set(\"hour\", dayjs(prev).hour())\n    .toDate();\n};\n\nconst dayjsRemovedTime = (date: dayjs.ConfigType) =>\n  dayjs(dayjs(date).format(\"YYYYMMDD\"));\n\nexport type CTCellProps = CellProps;\nexport type CTRenderCell = (props: CTCellProps) => JSX.Element;\n\nexport interface CalendarTimelineProps {\n  /**\n   * Cellをどのように描画するかを指定します。\n   * CellProps.dataからgroupsや日付の情報が取れるので自前でContextなどを用意する必要はありません。\n   * 注意：CellProps.styleを必ずコンポーネントに渡してください。\n   */\n  renderCell?: CTRenderCell;\n  /**\n   * @deprecated\n   * Use CalendarTimelineProps.renderCell instead.\n   *\n   * Cellがクリックされたときに呼ばれます。クリックされたCellを特定できる情報を返します。\n   */\n  onClickCell?: CTClickCellCallback;\n  /**\n   * 表示できる日付の範囲を指定します。\n   * @param activeMonthCount 有効な月数を指定します。指定がない場合、24になります。ここで指定された値は調整済みのdateを中心に両側に均等に割り振られます。つまり24の場合、去年と来年の同日まで閲覧できるようになります。\n   * @param start 有効範囲の最小値となる日付を指定します。activeMonthCountがある場合、設定できません。\n   * @param end 有効範囲の最大値となる日付を指定します。startと同様に日付の調整は行われません。activeMonthCountがある場合、設定できません。\n   * @param date Dateまたは日付を表すstringを指定してください。\n   * 【activeMonthCountが設定されている場合\b】：指定がない場合、new Date()相当の値が入ります。dateの指定した日付が最初から画面付近に入るように自動で1日または15日調整されます。\n   * 【activeMonthCountが設定されていない場合】：指定がない場合、startと同じ値が入ります。パターン1とは異なり、日付の調整が行われません。\n   */\n  visibleDates?:\n    | {\n        /**\n         * 基礎となる日付です。\n         * @default \"new Date()\"\n         */\n        date?: Date | string;\n        /**\n         * 表示できる月数。現在の想定では中心となる日付から左右に均等に割り振られます。\n         * @default 24\n         */\n        activeMonthCount?: number;\n        start?: never;\n        end?: never;\n      }\n    | {\n        /**\n         * 開始日\n         * @format \"YYYY-MM-DD\"\n         */\n        start: Date | string;\n        /**\n         * 終了日\n         * @format \"YYYY-MM-DD\"\n         */\n        end: Date | string;\n        /**\n         * 基礎となる日付です。\n         */\n        date?: Date | string;\n        activeMonthCount?: never;\n      };\n  /**\n   * 左上に表示される文字列です。\n   */\n  title?: string | (() => JSX.Element);\n  /**\n   * 縦方向の項目名に使用され、左側に表示されます。\n   * @param title 任意の文字列を渡します\n   * @param id 任意の文字列または数値。ここで指定したidはitems及びgroupコンポーネントのkeyとして利用されるため、ユニークである必要があります。\n   */\n  groups?: CTGroup[];\n  /**\n   * groupsで渡された値をどのように描画するかを指定します。groupsで指定したものに加えて、styleが渡されます。\n   */\n  renderGroup?: CTRenderGroup;\n  /**\n   * 予約などのイベントを表示するためコンポーネントに使用される値を配列で渡します。\n   * @param title 任意の文字列を渡します。\n   * @param start 開始日 Dateで時刻を考慮する必要があります。\n   * @param end 終了日 Dateで時刻を考慮する必要があります。\n   * @param group groupsで指定されたidを指定します。該当するgroupの行に配置されます。\n   * @param draggingProps dragAxisでドラッグ方向、disabledでドラッグ可能にするかどうかを指摘できます。\n   * @param itemProps 任意のHTMLPropsをItemに渡すことができます。\n   */\n  items: CTItem[];\n  /**\n   * itemsで渡された値をどのように描画するかを指定します。\n   * @param rowIndex 行番号。groups[rowIndex]で該当するgroupを取得できます。\n   * @param columnIndex 列番号。用途はほぼないと思います。\n   * @param itemIndex アイテム番号。items[itemIndex]で該当するitemを取得できます。\n   * @param title itemsで渡されたtitleです。\n   */\n  renderItem?: CTRenderItem;\n  /**\n   * itemのドラッグ操作が完了されたときに呼ばれます。\n   */\n  onDragItem?: CTDragItemCallback;\n  /**\n   * 列番号として使用される日付などの情報をどのように描画するかを指定します。\n   * @param date Date。移動先の日付です。時間情報は持っていません。\n   * @param style CSSProperties。必ず渡してください。\n   */\n  renderDate?: CTRenderDate;\n\n  /**\n   * 横方向にスクロールした際、先頭の日付を返します。\n   * 月や年より下の情報がいらない場合は適切に比較処理を行い、無駄な処理が行われないように注意してください。\n   */\n  onScroll?: CTScrollCallback;\n  /**\n   * itemのリサイズ操作が完了されたときに呼ばれます。\n   */\n  onResizeItem?: CTResizeItemCallback;\n  /**\n   * 余分に描画される列数を指定します。指定された列数をまたぐItemが存在する場合、位置によっては描画されない場合があります。\n   * @default 10\n   */\n  overscanColumnCount?: number;\n  /**\n   * 余分に描画される行数を指定します。指定された行数をまたぐItemが存在する場合、位置によっては描画されない場合があります。\n   * @default 10\n   */\n  overscanRowCount?: number;\n  /**\n   * 全てのアイテムのドラッグ方法を一括で指定できます。items propで個別にdraggingPropsで指定を行った場合、重複するものは上書きされます。\n   */\n  draggingProps?: CTDraggingProps;\n  /**\n   * 表示される行数を指定します。CalendarTimelineの高さはcellHeight * visibleRowCount + dateHeightで決定されます。\n   * @default 20\n   */\n  visibleRowCount?: number;\n  /**\n   * 表示される列数を指定します。CalendarTimelineの幅はcellWidth * visibleColumnCount + groupWidthで決定されます。\n   * @default 20\n   */\n  visibleColumnCount?: number;\n  /**\n   * 全てのアイテムに渡す任意のPropsを一括で指定できます。items propで個別にitemPropsで指定を行った場合、重複するものは上書きされます。\n   */\n  itemProps?: CTItemProps;\n  groupWidth?: number;\n  cellWidth?: number;\n  cellHeight?: number;\n  dateHeight?: number;\n}\n\nexport const CalendarTimeline = ({\n  groups: _groups,\n  items,\n  title,\n  onDragItem,\n  renderDate = DefaultDate,\n  renderItem = DefaultItem,\n  renderGroup = DefaultGroup,\n  renderCell = DefaultCell as CTRenderCell,\n  overscanColumnCount: defaultOverscanColumnCount = 10,\n  overscanRowCount: defaultOverscanRowCount = 10,\n  onScroll,\n  onResizeItem,\n  cellWidth = 64,\n  cellHeight = 27,\n  groupWidth = 230,\n  dateHeight = 64,\n  draggingProps,\n  itemProps,\n  visibleColumnCount = 20,\n  visibleRowCount = 20,\n  onClickCell,\n  visibleDates,\n}: CalendarTimelineProps) => {\n  const groups = useMemo(() => {\n    if (_groups && _groups.length > 0) {\n      return _groups;\n    } else {\n      return Array.from({ length: visibleRowCount }).map((_, i) => {\n        return {\n          id: `__DUMMY_GROUP_${i}__`,\n          title: \"\",\n        };\n      });\n    }\n  }, [_groups, visibleRowCount]);\n  const rowCount = useMemo(() => groups.length, [groups]);\n\n  const columns = useMemo(() => {\n    if (visibleDates?.start !== undefined) {\n      const length =\n        dayjs(visibleDates.end).diff(visibleDates.start, \"day\") + 1;\n      const startDate = dayjs(visibleDates.start);\n      return Array.from({ length }).map((_, i) => {\n        const date = startDate.clone().add(i, \"day\");\n        const day = date.date();\n        const weekday = date.day();\n        const month = date.month();\n        const year = date.year();\n        const dateString = date.format(\"YYYY-MM-DD\");\n        return {\n          date: date.toDate(),\n          weekday,\n          day,\n          month,\n          year,\n          dateString,\n        };\n      });\n    } else {\n      const activeMonthCount = visibleDates?.activeMonthCount ?? 24;\n      const date = visibleDates?.date ?? new Date();\n      const baseDate = dayjs(dayjs(date).format(\"YYYYMMDD\"));\n      const baseDay = baseDate.date() > 15 ? 14 : 1;\n      const startDate = baseDate\n        .add(Math.ceil(-activeMonthCount / 2), \"month\")\n        .set(\"date\", baseDay);\n      return Array.from({ length: activeMonthCount })\n        .map((_, i) => {\n          const dayOfStartMonth = startDate.clone().add(i, \"month\");\n          const daysInMonth = dayOfStartMonth.daysInMonth();\n          return Array.from({ length: daysInMonth }).map((_, j) => {\n            const date = dayOfStartMonth.clone().add(j, \"day\");\n            const day = date.date();\n            const weekday = date.day();\n            const month = date.month();\n            const year = date.year();\n            const dateString = date.format(\"YYYY-MM-DD\");\n            return {\n              date: date.toDate(),\n              weekday,\n              day,\n              month,\n              year,\n              dateString,\n            };\n          });\n        })\n        .flat();\n    }\n  }, [visibleDates]);\n\n  const columnCount = useMemo(() => columns.length, [columns]);\n\n  const initialScrollLeft = useMemo(() => {\n    if (visibleDates?.start === undefined) {\n      return (visibleDates?.activeMonthCount ?? 24) % 2 === 0\n        ? (columnCount / 2) * cellWidth\n        : (columnCount / 2 - 15) * cellWidth;\n    }\n    return visibleDates?.date !== undefined\n      ? dayjs(visibleDates.date).diff(visibleDates?.start, \"day\") * cellWidth\n      : 0;\n  }, [cellWidth, columnCount, visibleDates]);\n\n  const [editingCell, setEditingCell] = useState<\n    Partial<DraggableData> & {\n      columnIndex: number;\n      rowIndex: number;\n      x: number;\n      y: number;\n      lastX: number;\n      lastY: number;\n    }\n  >({\n    x: -1,\n    y: -1,\n    lastX: -1,\n    lastY: -1,\n    columnIndex: -1,\n    rowIndex: -1,\n  });\n  const [dragging, setDragging] = useState(false);\n  const handleDragStart: RndDragCallback = useCallback((event, data) => {\n    const columnIndex = parseInt(data.node.dataset.columnIndex as string, 10);\n    const rowIndex = parseInt(data.node.dataset.rowIndex as string, 10);\n    data.node.style.filter = \"opacity(100%)\";\n    data.node.style.zIndex = \"1\";\n    setEditingCell({\n      columnIndex,\n      rowIndex,\n      ...data,\n    });\n    setDragging(true);\n  }, []);\n  const handleDragStop: RndDragCallback = useCallback(\n    (event, data) => {\n      data.node.style.filter = \"\";\n      data.node.style.zIndex = \"0\";\n      if (onDragItem) {\n        const itemIndex = parseInt(data.node.dataset.itemIndex as string, 10);\n        const item = items[itemIndex];\n\n        const dragAxis =\n          draggingProps?.dragAxis || item.draggingProps?.dragAxis;\n        if (dragAxis === undefined) {\n          return;\n        }\n        const prev = { ...editingCell };\n        const x =\n          dragAxis === \"y\"\n            ? 0\n            : roundToZero((prev.lastX - data.lastX) / cellWidth);\n        const y =\n          dragAxis === \"x\" ? 0 : roundToZero((prev.y - data.y) / cellHeight);\n        if (x !== 0 || y !== 0) {\n          const date = columns[prev.columnIndex - x]?.date;\n          const group = groups[prev.rowIndex - y]?.id;\n          const diff = dayjs(date).diff(dayjsRemovedTime(item.start), \"date\");\n\n          if (date !== undefined && group !== undefined) {\n            const targetItem = {\n              ...item,\n              group,\n              start: addDate(item.start, diff),\n              end: addDate(item.end, diff),\n            };\n            const copy = items.slice();\n            copy[itemIndex] = targetItem;\n            onDragItem(copy, { ...targetItem, itemIndex });\n          }\n        }\n        setDragging(false);\n      }\n    },\n    [\n      cellHeight,\n      cellWidth,\n      columns,\n      draggingProps,\n      editingCell,\n      groups,\n      items,\n      onDragItem,\n    ]\n  );\n  const handleResizeStop: RndResizeCallback = useCallback(\n    (event, direction, ref, delta) => {\n      if (onResizeItem) {\n        const itemIndex = parseInt(ref.dataset.itemIndex as string, 10);\n        const copy = items.slice();\n        const item = copy[itemIndex];\n        if (direction === \"left\") {\n          const start = dayjs(item.start)\n            .add(roundToZero(-delta.width / cellWidth), \"day\")\n            .toDate();\n          copy[itemIndex] = {\n            ...item,\n            start,\n          };\n          onResizeItem(copy, {\n            itemIndex,\n            group: item.group,\n            start,\n            end: item.end,\n          });\n        } else if (direction === \"right\") {\n          const end = dayjs(item.end)\n            .add(roundToZero(delta.width / cellWidth), \"day\")\n            .toDate();\n          copy[itemIndex] = {\n            ...item,\n            end,\n          };\n          onResizeItem(copy, {\n            itemIndex,\n            group: item.group,\n            start: item.start,\n            end,\n          });\n        }\n      }\n    },\n    [cellWidth, items, onResizeItem]\n  );\n\n  const handleScroll = useCallback(\n    (props: GridOnScrollProps) => {\n      if (onScroll) {\n        onScroll(columns[roundToZero(props.scrollLeft / cellWidth)].date);\n      }\n    },\n    [cellWidth, columns, onScroll]\n  );\n\n  const itemData: CTCellProps[\"data\"] = useMemo(() => {\n    return {\n      makeHandleClick: onClickCell\n        ? ({\n            rowIndex,\n            columnIndex,\n          }: {\n            rowIndex: number;\n            columnIndex: number;\n          }) => {\n            return (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => {\n              const group = groups[rowIndex];\n              const column = columns[columnIndex];\n              onClickCell(\n                {\n                  column,\n                  group: {\n                    ...group,\n                    index: rowIndex,\n                  },\n                },\n                event\n              );\n            };\n          }\n        : undefined,\n      groups,\n      columns,\n      defaultStyles: defaultCellStyles,\n    };\n  }, [columns, groups, onClickCell]);\n\n  return (\n    <CalendarTimelineContext.Provider\n      value={{\n        columns,\n        items,\n        groups,\n        renderDate,\n        title,\n        editingCell,\n        renderGroup,\n        cellHeight,\n        cellWidth,\n        groupWidth,\n        dateHeight,\n        draggingProps,\n        itemProps,\n      }}\n    >\n      <ItemWrapperContext.Provider\n        value={{\n          cellHeight,\n          cellWidth,\n          handleDragStart,\n          handleDragStop,\n          handleResizeStop: onResizeItem ? handleResizeStop : undefined,\n          renderItem,\n        }}\n      >\n        <div\n          css={css`\n            position: relative;\n            display: flex;\n            flex-direction: row;\n            & .CalendarTimeline__Item {\n              filter: opacity(${dragging ? \"50%\" : \"100%\"});\n            }\n          `}\n        >\n          <Grid\n            onScroll={handleScroll}\n            className=\"CalendarTimeline__Main\"\n            columnCount={columnCount}\n            columnWidth={cellWidth}\n            height={cellHeight * visibleRowCount + dateHeight}\n            rowCount={rowCount}\n            rowHeight={cellHeight}\n            width={cellWidth * visibleColumnCount + groupWidth}\n            overscanColumnCount={defaultOverscanColumnCount}\n            overscanRowCount={defaultOverscanRowCount}\n            initialScrollLeft={initialScrollLeft}\n            innerElementType={InnerElement}\n            itemData={itemData}\n          >\n            {renderCell}\n          </Grid>\n        </div>\n      </ItemWrapperContext.Provider>\n    </CalendarTimelineContext.Provider>\n  );\n};\n"]} */")
+  }, ___EmotionJSX(Grid, {
+    onScroll: handleScroll,
+    className: "CalendarTimeline__Main",
+    columnCount: columnCount,
+    columnWidth: cellWidth,
+    height: cellHeight * visibleRowCount + dateHeight,
+    rowCount: rowCount,
+    rowHeight: cellHeight,
+    width: cellWidth * visibleColumnCount + groupWidth,
+    overscanColumnCount: defaultOverscanColumnCount,
+    overscanRowCount: defaultOverscanRowCount,
+    initialScrollLeft: initialScrollLeft,
+    innerElementType: InnerElement,
+    itemData: itemData
+  }, renderCell))));
+};
+//# sourceMappingURL=CalendarTimeline.js.map