Перейти к основному содержимому
Версия: 7.0

Отрисовка в React

Строки группы объектов, а также изображения и заголовки, которые проецирует платформа, представление React может рисовать компонентами и хуками платформы: они перерисовывают только изменившиеся строки, раскладывают строки по ячейкам и ведут страницу строк за прокруткой.

List, BucketScope, useBucket, Buckets и useSeekOnScroll построены на групповой и строчной форме проекции формы — data.<group>.list / .byKey / .keys, — поэтому служат только представлению формы, которое рисует строки этой группы, и никакому корню другого вида (Чтение проекции). Image и Caption рисуют переданное им значение под корнем любого вида.

Отрисовка строк​

Для отрисовки строк группы с экономией перерисовки по строкам используется window.lsfusion.List. Это глобальная переменная времени выполнения, поэтому, чтобы записать её как JSX-тег, сначала привяжите её к локальному имени с заглавной буквы. Без псевдонима вызывайте через React.createElement. Привязка выполняется там же, где выполняется модуль, а для собранного модуля и для ресурса .jsx это происходит до какой-либо отрисовки, поэтому её можно писать в начале модуля. В ресурсе, написанном сразу как .js, который отдаётся как есть, компоненты и хуки платформы читаются внутри компонента: модуль выполняется раньше, чем монтируется первое представление, а устанавливаются они при этом монтировании:

const List = window.lsfusion.List;
// ...
<List group="o" component={Row} />
// либо, без псевдонима:
React.createElement(window.lsfusion.List, { group: 'o', component: Row })

group — SID группы объектов. List читает строки группы из собственной проекции представления по этому имени, так же как это делает BucketScope, поэтому ему передаётся имя, а не узел. keys размещает часть этих строк в визуальном блоке, в заданном порядке. Например, внутри BucketScope для o, чей bucketOf использует вычисленное сервером свойство строки, каждая ячейка рисует свои строки:

function OrderCell({cellKey}) {
const keys = window.lsfusion.useBucket(cellKey);
return <List group="o" keys={keys} component={Row} />;
}

Отбор и сортировка строк выполняются на сервере через фильтры и сортировки, а не фильтрацией или сортировкой загруженной страницы на JavaScript.

Ключ, которого в группе нет, не отрисовывает ничего. List, получивший группу, строки которой это представление не рисует, — такую, от которой у представления есть лишь панельное свойство или нет ничего вовсе, — бросает исключение: рисует ли представление строки группы, задаёт дизайн формы, а не её данные, поэтому это ошибка в представлении, и представление показывает причину на своём месте и в консоли. List рисует те строки, которые есть в проекции, а грид, который форма скрывает через SHOWIF, свои строки сохраняет, как и грид самой платформы: если у грида есть SHOWIF, рисуйте List, только пока props.data['GRID(o)'].hidden не установлен.

Отрисовывайте List как компонент — через JSX или React.createElement, — а не вызывая его как обычную функцию: каждая строка отрисовывается компонентом, использующим хуки, поэтому он работает только когда его монтирует React.

List задаёт каждой строке ключ row.key, передаёт строку в компонент как props.row — вместе с rowKey, index и любыми другими свойствами, переданными в List, кроме его собственных group, keys и component — или children, который задаёт компонент строки, когда component не задан, — и отрисовывает каждую строку через мемоизированную обёртку, привязанную к этой строке, поэтому при изменении перерисовываются только реально изменившиеся строки. Простая альтернатива отображает список напрямую:

props.data.o.list.map(r => <Row key={r.key} row={r} />)

Зачем нужна экономия перерисовки по строкам. При изменении любой одной строки props.data.<g>.list пересоздаётся как новая ссылка на массив, но проекция сохраняет прежнюю ссылку на объект для каждой не изменившейся строки (структурное разделение) — новый объект строки получают только строки, содержимое которых изменилось. Простой list.map(r => <Row row={r}/>) пересоздаёт элемент Row для каждой записи при изменении любой одной строки, поэтому React перерисовывает их все. Ключ React key этого не меняет: он позволяет React сохранять идентичность элемента строки, её DOM и состояние компонента между перерисовками, но не отменяет саму перерисовку. Компилятор React тоже не помогает — он мемоизирует .map как одну реактивную область по ссылке на массив, которая только что изменилась, и не оборачивает дочерние строки в React.memo, поэтому все строки всё равно перерисовываются.

window.lsfusion.List добавляет недостающую отмену перерисовки по строкам: каждая строка отрисовывается через стабильную мемоизированную обёртку, которая следит за этой одной строкой, поэтому изменение значения перерисовывает только изменившуюся строку. Сам список не обходится заново при изменении значения строки — только при добавлении, удалении или перестановке строк, — поэтому обновление рисует только изменившееся. С числом строк растёт лишь проверка своей подписки каждой смонтированной строкой — поиск по её ключу. Чтобы получить отмену перерисовки по строкам вручную без window.lsfusion.List, объявите мемоизированный компонент строки один раз на уровне модуля и задавайте ключ row.key:

const MRow = React.memo(Row);
// ...
props.data.o.list.map(r => <MRow key={r.key} row={r} />)

React.memo(Row), создаваемый внутри компонента при каждой перерисовке, каждый раз является новым типом компонента, что сводит мемоизацию на нет и перерисовывает все строки.

Раскладка строк по ячейкам​

Когда представление раскладывает строки группы не списком, а матрицей — календарь, канбан-доска, расписание, схема рассадки, — каждая строка попадает в производную ячейку (день × сотрудник, колонка статуса и т. п.). window.lsfusion.BucketScope поддерживает индекс ячейка → строки по одной группе, и каждая ячейка подписывается только на свой состав.

<BucketScope group bucketOf bucketDeps> оборачивает разметку сетки. group — SID группы объектов. Группа, строки которой это представление не рисует, приводит к исключению — так же, как в List. bucketOf(row, rowKey) вычисляет ключ ячейки строки из значений её свойств — строку (любое значение приводится к строке), массив ключей, чтобы поместить строку в несколько ячеек, или null, чтобы никуда не помещать. bucketDeps перечисляет внешние значения, которые захватывает bucketOf, — как массив зависимостей хука, индекс перестраивается при их изменении. Длина массива должна оставаться постоянной.

useBucket(cellKey) возвращает массив ключей строк, находящихся сейчас в этой ячейке, в порядке отображения группы, и подписывает компонент только на эту ячейку. Вызывайте его один раз в компоненте ячейки, с её фиксированным ключом (обычные правила хуков). Пустая ячейка всегда возвращает один и тот же замороженный пустой массив. Компонент ячейки превращает каждый ключ строки в компонент строки, который подписывается на свою строку через useData(d => d.<g>.byKey[rowKey]).

Раскладка остаётся за представлением: оно задаёт ключи ячеек — поэтому пустые ячейки существуют и отрисовываются, например как цели перетаскивания, — и разметку ячейки. За платформой — индекс и экономия перерисовки: перемещение строки между ячейками перерисовывает только старую и новую ячейку; изменение значения, не меняющее ячейку строки, перерисовывает только компонент самой строки; все остальные ячейки сохраняют прежнюю ссылку на массив, и их React.memo пропускает перерисовку. Простая альтернатива — самостоятельно группировать data.<g>.list по ячейкам на каждом рендере — каждый раз пересоздаёт массив каждой ячейки, поэтому любое изменение перерисовывает всю доску.

Когда ячейки образуют плоский список и вся разметка ячейки живёт в одном компоненте, форма <Buckets group cells bucketOf component/> выполняет отображение сама, как List для строк: по одной мемоизированной обёртке на каждый ключ из cells, а компонент ячейки получает cellKey, rowKeys, index и транзитные props. Явную разметку <BucketScope> + useBucket оставляйте, когда сетку размечает само представление — двумерная матрица, заголовки осей, закреплённые колонки:

const { Buckets } = window.lsfusion;
const STATUSES = ['new', 'inProgress', 'done'];

// Card подписывается на свою строку
const Column = ({ cellKey, rowKeys }) => (
<div className="column">{rowKeys.map(k => <Card key={k} rowKey={k} />)}</div>
);

<Buckets group="t" cells={STATUSES} bucketOf={t => t.status.value} component={Column} />

Используйте раскладку по ячейкам, чтобы помещать строки одной группы в производные ячейки, когда важен только состав, — сводные таблицы, календари, канбан-доски, расписания, сетки с перетаскиванием. Она не вычисляет агрегаты по ячейкам: useBucket возвращает ключи строк, а не суммы или количества, и компонент ячейки перерисовывается, только когда меняется массив ключей строк этой ячейки, — живые агрегаты даёт вид представления сводная таблица. Для обычного списка строк один к одному используйте List. Группировка работает только по собственным спроецированным значениям группы.

Отслеживание прокрутки​

Представление, раскладывающее строки в их собственном порядке — поток карточек, лента, — может не читать все строки, а сохранить страницу и вести её за прокруткой, как это делает стандартная таблица. useSeekOnScroll(controller.<group>) возвращает функцию, которой помечается элемент каждой строки. Хук следит, какие из них видны на экране при прокрутке собственного блока представления — ближайшего элемента, прокручивающего строки, который ищется от строки вверх до элемента, в котором нарисовано представление, и не дальше, — и следует правилам самой таблицы: пока текущая запись на экране, прокрутка ничего не меняет; когда она выходит за экран — пересаживается на видимую кромку, через которую вышла, что и запрашивает следующую страницу; при смене страницы пересаженная строка сохраняет свою позицию на экране, так что под взглядом ничего не прыгает; текущая запись, изменённая извне — кликом или программным переходом, — наоборот, докручивается в видимость. Пакт держится на том же контракте, на котором живёт сама таблица, и он на стороне разработчика: страница должна вмещать больше строк, чем видно на экране, — задайте соответствующий PAGESIZE в блоке OBJECTS. Тогда окно всегда простирается на страницу дальше текущей записи, и она выходит за экран — и пересаживается, подтягивая следующую страницу, — раньше, чем прокрутке станет некуда двигаться у края загруженного:

const seekRef = useSeekOnScroll(controller.o, { enabled: follow });
...
{rows.map(row => <div key={row.key} ref={seekRef(row)}>...</div>)}

Опции: enabled (по умолчанию true) приостанавливает слежение, threshold (0.6) — какая часть элемента должна быть видна, чтобы считаться на экране, settle (250 мс) — сколько набор строк на экране должен оставаться прежним, прежде чем представление перейдёт, — отсчёт начинается заново, когда строка появляется на экране или уходит с него, а не при каждом событии прокрутки, onSeek(row) вызывается при каждом переходе. Используйте один useSeekOnScroll на прокручиваемый элемент. Строки, считанные для новой позиции, заменяют list, и всё построенное из него — значения и размещённые представления lsFusion — следует за ними.

Хук меняет позицию прокрутки этого блока и отключает в нём собственную привязку прокрутки браузера, поэтому не трогает ничего вне элемента, в котором нарисовано представление: всё, что там, — платформенный контейнер, блок, общий с другим представлением, страница, блок портала — принадлежит чему-то другому. Если строки прокручиваются только в таком элементе, хук не делает ничего — не переходит и не прокручивает к текущей строке, ушедшей из виду, — и один раз сообщает об этом в консоли. Дайте строкам собственный прокручиваемый блок представления — ограниченную высоту и overflow: auto.

Отрисовка изображения​

Изображение, которое проецирует платформа, — свойство класса изображения, значок элемента навигатора или действия — рисуется компонентом Image:

const { Image } = window.lsfusion;

<Image value={e.image} className="menu-icon"/>
<Image value={row.photo.value} className="avatar"/>

Проецируемое значение — это либо адрес, либо готовый элемент, поскольку у шрифтового значка адреса нет вовсе, и Image рисует то, что ему передали. Представлению, которому нужен сам адрес — например, для фона в CSS, — он по-прежнему доступен в значении. Image существует для того, чтобы разметку платформы не приходилось вставлять руками. Отсутствующее изображение не рисуется.

Отрисовка заголовка​

Заголовок, который проецирует платформа, — заголовок формы, элемента навигатора или сообщения — рисуется компонентом Caption:

const { Caption } = window.lsfusion;

<Caption value={e.caption} className="tab-caption"/>

Заголовок — это либо обычный текст, либо разметка, построенная платформой, и Caption рисует то, что ему передали, по тому же правилу, по которому платформа рисует собственный заголовок: значение считается разметкой, если тег встречается в нём где угодно. Напечатанный как текст, такой заголовок показал бы собственную разметку, поэтому представление, которое печатает {e.caption} само, право только пока заголовок — обычный текст. Отсутствующий заголовок не рисуется.

Ступени производительности​

Два способа чтения проекции складываются в ступени, и каждая следующая нужна лишь тогда, когда перерисовка предыдущей становится ценой:

  1. небольшое представление — props.data, рисуется всё;
  2. список подлиннее — props.data плюс компоненты строк, мемоизированные на уровне модуля (React.memo отсекает по стабильным ссылкам не изменившихся строк), или List, который делает ровно это;
  3. большая доска — подписки вниз по дереву: корень рисует мемоизированные колонки и не передаёт им data, колонка подписана на свою ячейку, строка — на себя, и одно изменённое значение перерисовывает корень и одну карточку.