TypeScript dx-core.PureComputed類代碼示例

export const getCollapsedGrids: GetCollapsedGridsFn = ({
    headerRows = [],
    bodyRows = [],
    footerRows = [],
    columns,
    loadedRowsStart,
    totalRowCount,
    getCellColSpan,
    viewportLeft,
    containerWidth,
    visibleRowBoundaries,
    getColumnWidth,
    getRowHeight,
  },
) => {
  const getColSpan = (
    tableRow: any, tableColumn: any,
  ) => getCellColSpan!({ tableRow, tableColumn, tableColumns: columns });

  const columnBoundaries = getColumnBoundaries(
    columns, viewportLeft, containerWidth, getColumnWidth,
  );
  const getCollapsedGridBlock: PureComputed<
    [any[], any[]?, number?, number?], CollapsedGrid
  > = (
    rows, rowsVisibleBoundary, rowCount = rows.length, offset = 0,
  ) => getCollapsedGrid({
    rows,
    columns,
    rowsVisibleBoundary,
    columnsVisibleBoundary: columnBoundaries,
    getColumnWidth,
    getRowHeight,
    getColSpan,
    totalRowCount: rowCount,
    offset,
  });

  const headerGrid = getCollapsedGridBlock(
    headerRows, getRenderRowBounds(visibleRowBoundaries.header, headerRows.length),
  );
  const bodyGrid = getCollapsedGridBlock(
    bodyRows,
    adjustedRenderRowBounds(
      visibleRowBoundaries.body, bodyRows.length, loadedRowsStart,
    ),
    totalRowCount || 1,
    loadedRowsStart,
  );
  const footerGrid = getCollapsedGridBlock(
    footerRows, getRenderRowBounds(visibleRowBoundaries.footer, footerRows.length),
  );

  return {
    headerGrid,
    bodyGrid,
    footerGrid,
  };
};

export const rowIdGetter: PureComputed<[GetRowIdFn, Row[]]> = (getRowId, rows) => {
  if (!getRowId) {
    const map = new Map(rows.map((row, rowIndex) => [row, rowIndex]) as [any, number]);
    return (row: Row) => map.get(row) as RowId;
  }
  return warnIfRowIdUndefined(getRowId);
};

export const timeBoundariesByDrag: TimeBoundariesByDrag = (
  payload, targetData, targetType,
  cellDurationMinutes, insidePart, offsetTimeTopBase,
) => {
  let offsetTimeTop;
  let appointmentStartTime;
  let appointmentEndTime;

  const insideOffset = calculateInsideOffset(targetType, insidePart, cellDurationMinutes);
  const start = moment(targetData.startDate as Date).add(insideOffset, SECONDS);

  if (offsetTimeTopBase === null) {
    offsetTimeTop = moment(targetData.startDate as Date)
      .diff(payload.startDate as Date, SECONDS) + insideOffset;
  } else {
    offsetTimeTop = offsetTimeTopBase;
  }

  if (payload.type === targetType) {
    const appointmentDurationSeconds = intervalDuration(payload, SECONDS);
    appointmentStartTime = moment(start).add((offsetTimeTop) * (-1), SECONDS).toDate();
    appointmentEndTime = moment(start)
      .add((appointmentDurationSeconds - offsetTimeTop), SECONDS).toDate();
  } else {
    appointmentStartTime = moment(targetData.startDate as Date)
      .add(insideOffset, SECONDS).toDate();
    appointmentEndTime = moment(targetData.endDate as Date).add(insideOffset, SECONDS).toDate();
  }

  return { appointmentStartTime, appointmentEndTime, offsetTimeTop };
};

> = (
  appointment,
  {
    rectByDates,
    multiline,
    rectByDatesMeta: {
      cellElements,
      viewCellsData,
    },
  },
) => {
  const {
    top, left,
    width, height, parentWidth,
  } = rectCalculatorBase(
    appointment,
    rectByDates,
    {
      multiline,
      cellElements,
      viewCellsData,
    },
  );

  return {
    top: top + ((height / appointment.reduceValue) * appointment.offset),
    height: height / appointment.reduceValue,
    left: toPercentage(left, parentWidth),
    width: toPercentage(width, parentWidth),
    dataItem: appointment.dataItem,
    fromPrev: appointment.fromPrev,
    toNext: appointment.toNext,
    type: HORIZONTAL_TYPE,
  };
};

export const mergeRows: MergeRowsFn = (
  rowsInterval, cacheInterval, rows, cacheRows, rowsStart, cacheStart,
) => {
  const breakpoints = [
    rowsInterval.start, rowsInterval.end,
    cacheInterval.start, cacheInterval.end,
  ]
    .filter(i => 0 <= i && i < Number.POSITIVE_INFINITY)
    .sort((a, b) => a - b);

  let result: Row[] = [];
  if (breakpoints.length > 1) {
    for (let i = 0; i < breakpoints.length - 1; i += 1) {
      const left = breakpoints[i];
      const right = breakpoints[i + 1];
      const chunk = rowsInterval.start <= left && right <= rowsInterval.end
        ? pluckSubarray(rows, rowsStart, left, right) // rows have higher priority
        : pluckSubarray(cacheRows, cacheStart, left, right);

      result = result.concat(chunk);
    }
  }

  return {
    skip: breakpoints[0],
    rows: result,
  };
};

export const viewBoundText: ViewBoundTextFn = (
  startViewDate, endViewDate, step, currentDate, intervalCount, formatDate,
) => (
  step !== 'month'
    ? calculateTextByDays(startViewDate, endViewDate, formatDate)
    : calculateTextByMonths(currentDate, intervalCount, formatDate)
);

> = (timeTableCells, clientOffset) => timeTableCells.findIndex((timeTableCell) => {
  const {
    left, top,
    right, bottom,
  } = timeTableCell.getBoundingClientRect();
  const isOver = clientOffset
      && clamp(clientOffset.x, left, right) === clientOffset.x
      && clamp(clientOffset.y, top, bottom) === clientOffset.y;
  return isOver;
});

    .findIndex((geometry, index) => {
      const inVerticalBounds = isOnTheSameLine(geometry, y);
      const inHorizontalBounds = x >= geometry.left && x <= geometry.right;
      const shouldGoFirst = index === 0 && x < geometry.left;
      const shouldGoOnLineBreak = !inVerticalBounds
        && !!geometries[index - 1]
        && isOnTheSameLine(geometries[index - 1], y);

      return (inVerticalBounds && inHorizontalBounds)
        || shouldGoFirst
        || shouldGoOnLineBreak;
    });

export const calculateRectByDateIntervals: CalculateRectByDateIntervalsFn = (
  type, intervals, rectByDates, rectByDatesMeta,
) => {
  const { growDirection, multiline } = type;
  const sorted = sortAppointments(intervals, multiline);
  const grouped = findOverlappedAppointments(sorted as AppointmentMoment[], multiline);

  const rectCalculator = growDirection === HORIZONTAL_TYPE
    ? horizontalRectCalculator
    : verticalRectCalculator;

  return unwrapGroups(adjustAppointments(grouped, multiline))
    .map(appointment => rectCalculator(appointment, { rectByDates, multiline, rectByDatesMeta }));
};

export const sortedRows: SortedRowsFn = (
  rows, sorting, getCellValue, getColumnCompare, isGroupRow, getRowLevelKey,
) => {
  if (!sorting.length || !rows.length) return rows;

  let compare;
  if (!getRowLevelKey) {
    compare = createCompare(sorting, getColumnCompare, getCellValue);
    return mergeSort(rows.slice(), compare);
  }

  compare = createCompare(sorting, getColumnCompare, (row, columnName) => {
    if (isGroupRow && isGroupRow(row)) {
      if (row.groupedBy === columnName) {
        return row.value;
      }
      return undefined;
    }
    return getCellValue(row, columnName);
  });
  return sortHierarchicalRows(
    rows,
    compare,
    getRowLevelKey,
  );
};