@atlaskit/renderer 137.1.8 → 137.1.10

package/dist/esm/ui/expand-body.js

@@ -1,114 +0,0 @@
-import React, { createContext, isValidElement, useContext } from 'react';
-import { isExperimentEnabled } from '@atlaskit/platform-feature-experiments/is-experiment-enabled';
-import { BLOCK_SEPARATOR, getBlockSearchText, holdsRevealableContent, isExpandNode } from './utils/expand-search-text';
-var ExpandBodyContext = /*#__PURE__*/createContext(null);
-export var ExpandBodyProvider = ExpandBodyContext.Provider;
-export var useExpandBody = function useExpandBody() {
-  return useContext(ExpandBodyContext);
-};
-/**
- * One or more neighbouring blocks of an expand's body. Shows their text until the expand is
- * opened, then renders them. Falls back to rendering if there is no text, or if there is no
- * expand above it.
- *
- * The text is rendered as-is, with no element around it. Nothing reads it but browser find,
- * which only needs the characters to be in the DOM.
- */
-export var ExpandBodyBlock = function ExpandBodyBlock(_ref) {
-  var children = _ref.children,
-    searchText = _ref.searchText;
-  var body = useExpandBody();
-  if (searchText === undefined || body === null || body.revealed) {
-    return /*#__PURE__*/React.createElement(React.Fragment, null, children);
-  }
-  return searchText;
-};
-
-/**
- * Called for every node the serializer renders. If the node is a block of an expand's body,
- * wraps it so it can show its text instead of rendering while that expand is collapsed.
- * Everything else is returned untouched.
- *
- * A block holding an expand of its own is also returned untouched, so a table with a nested
- * expand in it, or an extension holding stashed ADF, renders even while collapsed. That
- * expand needs an element of its own, because the element browser find reveals is the only
- * way we learn the match was inside it rather than higher up. We give up the saving on those
- * blocks so the reader searches once instead of once per level.
- *
- * `ancestors` is the node's ancestor chain, nearest last.
- */
-export var withExpandBodyBlock = function withExpandBodyBlock(node, ancestors, index, serialized) {
-  var parent = ancestors[ancestors.length - 1];
-  if (!parent || !isExpandNode(parent)) {
-    return serialized;
-  }
-  if (!isExperimentEnabled('platform_editor_defer_collapsed_expand_body') || holdsRevealableContent(node)) {
-    return serialized;
-  }
-  var searchText = getBlockSearchText(node);
-  if (searchText === undefined) {
-    return serialized;
-  }
-  return /*#__PURE__*/React.createElement(ExpandBodyBlock, {
-    key: "expand-body-block-".concat(index),
-    searchText: searchText
-  }, serialized);
-};
-
-/** Whatever the serializer produced for one child: an element, a string, an array of either. */
-
-var searchTextOf = function searchTextOf(child) {
-  return /*#__PURE__*/isValidElement(child) && child.type === ExpandBodyBlock ? child.props.searchText : undefined;
-};
-
-/**
- * Joins neighbouring blocks that are showing text into one, so a run of them is a single string in
- * the DOM rather than one per block. A body of twenty paragraphs becomes one text node instead of
- * twenty.
- *
- * A block that is being rendered — a nested expand, say — ends the run, because the text either
- * side of it has to stay either side of it.
- */
-export var mergeExpandBodyText = function mergeExpandBodyText(children) {
-  // Called for every fragment in the document, and only an expand's body has anything to merge, so
-  // leave the array alone unless two neighbours are actually showing text.
-  var hasRun = children.some(function (child, index) {
-    return index > 0 && searchTextOf(child) !== undefined && searchTextOf(children[index - 1]) !== undefined;
-  });
-  if (!hasRun) {
-    return children;
-  }
-  var merged = [];
-  var run = [];
-  var endRun = function endRun() {
-    if (run.length === 0) {
-      return;
-    }
-    if (run.length === 1) {
-      merged.push(run[0]);
-    } else {
-      var _key;
-      var text = run.map(searchTextOf).filter(Boolean).join(BLOCK_SEPARATOR);
-      // The blocks themselves, not the wrappers around them: nesting the wrappers would show
-      // each block's text again inside the joined run.
-      var blocks = run.map(function (child) {
-        return child.props.children;
-      });
-      merged.push( /*#__PURE__*/React.createElement(ExpandBodyBlock, {
-        key: (_key = run[0].key) !== null && _key !== void 0 ? _key : undefined,
-        searchText: text
-      }, blocks));
-    }
-    run = [];
-  };
-  children.forEach(function (child) {
-    if (searchTextOf(child) === undefined) {
-      endRun();
-      merged.push(child);
-      return;
-    }
-    run.push(child);
-  });
-  endRun();
-  return merged;
-};

package/dist/types/react/nodes/tableNew.d.ts

@@ -1,189 +0,0 @@
-import React from 'react';
-import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
-import type { TableLayout } from '@atlaskit/adf-schema';
-import type { OverflowShadowProps } from '@atlaskit/editor-common/ui';
-import { SortOrder } from '@atlaskit/editor-common/types';
-import type { RendererAppearance, StickyHeaderConfig } from '../../ui/Renderer/types';
-import type { WithSmartCardStorageProps } from '../../ui/SmartCardStorage';
-import type { StickyMode } from './table/sticky';
-import { OverflowParent } from './table/sticky';
-import type { SharedTableProps } from './table/types';
-import { TableStickyScrollbar } from './TableStickyScrollbar';
-export type TableArrayMapped = {
-    rowNodes: Array<PMNode | null>;
-    rowReact: React.ReactElement;
-};
-export declare const isTableResizingEnabled: (appearance: RendererAppearance) => boolean;
-export declare const isStickyScrollbarEnabled: (appearance: RendererAppearance) => boolean;
-export declare const orderChildren: (children: React.ReactElement[], tableNode: PMNode, smartCardStorage: WithSmartCardStorageProps['smartCardStorage'], tableOrderStatus?: TableOrderStatus) => React.ReactElement[];
-export declare const hasRowspan: (row: PMNode) => boolean;
-export declare const getRefTop: (refElement: HTMLElement) => number;
-export declare const shouldHeaderStick: (scrollTop: number, tableTop: number, tableBottom: number, rowHeight: number) => boolean;
-export declare const shouldHeaderPinBottom: (scrollTop: number, tableBottom: number, rowHeight: number) => boolean;
-export declare const addSortableColumn: (rows: React.ReactElement<any>[], tableOrderStatus: TableOrderStatus | undefined, onSorting: (columnIndex: number, sortOrder: SortOrder) => void) => React.ReactElement<any, string | React.JSXElementConstructor<any>>[];
-export type TableProps = SharedTableProps & {
-    allowColumnSorting?: boolean;
-    allowTableAlignment?: boolean;
-    allowTableResizing?: boolean;
-    children: React.ReactElement<any> | Array<React.ReactElement<any>>;
-    isPresentational?: boolean;
-    rendererAppearance?: RendererAppearance;
-    stickyHeaders?: StickyHeaderConfig;
-    tableNode?: PMNode;
-};
-export declare const isHeaderRowEnabled: (rows: (React.ReactElement | number | string | React.ReactFragment | React.ReactPortal)[]) => any;
-export declare const tableCanBeSticky: (node: PMNode | undefined, children: (React.ReactElement | number | string | React.ReactFragment | React.ReactPortal)[]) => any;
-export interface TableOrderStatus {
-    columnIndex: number;
-    order: SortOrder;
-}
-export interface TableState {
-    headerRowHeight: number;
-    stickyMode: StickyMode;
-    wrapperWidth: number;
-}
-/**
- * Reads `nestedRendererType` from RendererContext and renders the fake left/right
- * borders only when the current renderer is the nested renderer for a reference
- * synced block.
- */
-export declare const RefSyncBlockFakeBorders: ({ isNumberColumnEnabled, }: {
-    isNumberColumnEnabled: boolean;
-}) => React.JSX.Element | null;
-/**
- * TableContainer renders tables using only CSS-based rules
- */
-/**
- *
- */
-export declare class TableContainer extends React.Component<TableProps & OverflowShadowProps & WithSmartCardStorageProps, TableState> {
-    state: TableState;
-    tableRef: React.RefObject<HTMLTableElement>;
-    stickyHeaderRef: React.RefObject<HTMLElement>;
-    stickyScrollbarRef: React.RefObject<HTMLDivElement>;
-    stickyWrapperRef: React.RefObject<HTMLDivElement>;
-    wrapperRef: React.RefObject<HTMLDivElement>;
-    stickyScrollbar?: TableStickyScrollbar;
-    nextFrame: number | undefined;
-    overflowParent: OverflowParent | null;
-    updatedLayout: TableLayout | 'custom';
-    private containerRef;
-    private _isInsideNestedRenderer;
-    private _isInsideTableCell;
-    private lastComputedStyle;
-    private resizeObserver;
-    private applyResizerChange;
-    /**
-     * Checks if this table is inside a nested renderer (e.g. Include Page macro)
-     * by looking for multiple .ak-renderer-document ancestors in the DOM.
-     * The result is cached since a table's position in the DOM tree is stable after mount.
-     */
-    private isInsideNestedRenderer;
-    /**
-     * Checks if this table is inside a table cell in the DOM. The result is cached
-     * since a table's position in the DOM tree is stable after mount.
-     */
-    private isInsideTableCell;
-    private isInsideTableContext;
-    /**
-     * For tables inside nested renderers (e.g. Include Page macro), the parent
-     * renderer's CSS override forces width:100%!important and left:0!important
-     * which overrides the inline styles set by this component. Using
-     * style.setProperty with 'important' priority on inline styles beats
-     * stylesheet !important rules per the CSS cascade.
-     *
-     * Tables that are nested inside another table need to remain constrained by
-     * their table-cell context. Do not promote their width to inline !important,
-     * otherwise nested tables rendered through macros such as Excerpt Include can
-     * overflow and overlap adjacent cells.
-     *
-     * Top-level tables in nested renderers still preserve their saved width, but
-     * are capped to their containing block so wide tables do not escape constrained
-     * macro bodies such as Excerpt Include panels.
-     *
-     * Uses lastComputedStyle (populated during render) rather than reading from
-     * element.style, because React may remove properties from the DOM when their
-     * values transition to undefined between renders.
-     *
-     * `platform_nested_table_style_override_2` fixes a follow-up regression where a
-     * NON-resized table inside an Excerpt macro (not Excerpt Include) on a
-     * wide/full-width page shrinks to only show its first columns in the renderer.
-     * Inside a nested renderer (a macro body) a non-resized table's computed width
-     * is a default layout cap (760px/1800px, or a `cqw` length for full-page
-     * appearances) taken from the outer renderer's width context. That value does
-     * not match the macro's own box, so promoting it to inline `!important` makes
-     * the table collapse. Such tables have no author-chosen size to preserve, so
-     * under this gate we re-assert the parent stylesheet's intent (fill the box:
-     * `width: 100%; left: 0`) with inline `!important`.
-     *
-     * Explicitly resized tables (`tableNode.attrs.width` set) are excluded and keep
-     * the original PGXT-10226 behavior: their author-chosen width/left is promoted
-     * verbatim so the Include Page macro does not stretch or indent them. The
-     * table-cell short-circuit (PGXT-10294) above also still applies.
-     */
-    private applyNestedRendererTableFix;
-    /**
-     * Callback ref that captures the container DOM element and also forwards
-     * to the handleRef prop from the overflow shadow HOC.
-     */
-    private setContainerRef;
-    /**
-     * Starts observing table dimensions and wires sticky header/scrollbar behavior after mount.
-     *
-     * @example
-     */
-    componentDidMount(): void;
-    /**
-     * Updates sticky header wiring and scroll synchronization after prop or state changes.
-     *
-     * @param prevProps
-     * @param prevState
-     * @example
-     */
-    componentDidUpdate(prevProps: TableProps, prevState: TableState): void;
-    componentWillUnmount: () => void;
-    getScrollTop: () => number;
-    updateSticky: () => void;
-    onScroll: () => void;
-    onWrapperScrolled: () => void;
-    /**
-     * Calculates the top offset used when the sticky header is pinned to the table bottom.
-     */
-    get pinTop(): number | undefined;
-    /**
-     * Determines whether sticky header positioning should include the default scroll root offset.
-     */
-    get shouldAddOverflowParentOffsetTop_DO_NOT_USE(): boolean | null | undefined;
-    /**
-     * Resolves the top position for the sticky header based on the current sticky mode.
-     */
-    get stickyTop(): number | undefined;
-    /**
-     * Renders the table container, sticky header, table content, sticky scrollbar, and synced block borders.
-     *
-     * @example
-     */
-    render(): React.JSX.Element;
-    private grabFirstRowRef;
-}
-type TableProcessorState = {
-    tableOrderStatus?: TableOrderStatus;
-};
-/**
- * Processes table children before passing them to the styled table container.
- */
-export declare class TableProcessorWithContainerStyles extends React.Component<TableProps & OverflowShadowProps & WithSmartCardStorageProps, TableProcessorState> {
-    state: {
-        tableOrderStatus: undefined;
-    };
-    /**
-     * Renders processed table children inside the table container.
-     *
-     * @example
-     */
-    render(): React.JSX.Element | null;
-    private addSortableColumn;
-    private changeSortOrder;
-    private addNumberColumnIndexes;
-}
-export {};