@netgrif/components-core
Version:
Netgrif Application engine frontend core Angular library
249 lines • 33.6 kB
JavaScript
import { IncrementingCounter } from '../../utility/incrementing-counter';
import { TaskElementType } from './task-content-element-type';
import { BehaviorSubject } from 'rxjs';
/**
* A configuration for one subgrid - a basic layouting unit
*/
export class Subgrid {
subgridId;
cols;
_asyncRenderingConfig;
/**
* the css `gridAreas` configuration, that determines the layout of the grids content
*/
gridAreas;
/**
* The elements that are contained in the subgrid
*/
_content = [];
/**
* The elements that are contained in the subgrid and have already been rendered to the user
*/
_renderedContent$;
/**
* A 2D representation of the grid element IDs
*/
_grid = [];
/**
* Counter to assure element ID uniqueness
*/
_runningTitleCount = new IncrementingCounter();
/**
* Grid area identifiers that are already in use
*/
_existingIdentifiers = new Set();
_asyncRenderingTimeout;
_keptElements;
_newElements;
/**
* @param subgridId a unique identifier of the subgrid in the task layout
* @param cols Number of columns of the subgrid
* @param _asyncRenderingConfig configuration object for async rendering of data fields
*/
constructor(subgridId, cols, _asyncRenderingConfig) {
this.subgridId = subgridId;
this.cols = cols;
this._asyncRenderingConfig = _asyncRenderingConfig;
this._renderedContent$ = new BehaviorSubject([]);
}
get content() {
return this._renderedContent$.value;
}
/**
* Completes the underlying stream and clears any running timeouts
*/
destroy() {
this._renderedContent$.complete();
if (this._asyncRenderingTimeout !== undefined) {
window.clearTimeout(this._asyncRenderingTimeout);
}
}
/**
* @returns the columns configuration for the grid layout
*/
getGridColumns() {
return 'repeat(' + this.cols + ', 1fr)';
}
getRunningTitleCount() {
return this._runningTitleCount;
}
/**
* Converts a {@link DataField} into a {@link DatafieldGridLayoutElement} and adds it to the content of this subgrid.
*
* Beware that this method DOES NOT add the element into the resulting grid. This must be done independently by calling the
* [addRow]{@link Subgrid#addRow} method.
* @param field the field that should be added to the subgrid
* @param type the type of the field
* @returns the created grid element
*/
addField(field, type) {
const element = this.fieldElement(field, type);
this.addElement(element);
return element;
}
/**
* Converts a {@link DataGroup} into a {@link DatafieldGridLayoutElement} and adds it to the content of this subgrid.
*
* Beware that this method DOES NOT add the element into the resulting grid. This must be done independently by calling the
* [addRow]{@link Subgrid#addRow} method.
* @param dataGroup the data group whose title should be added to the grid
* @returns the created grid element
*/
addTitle(dataGroup) {
const element = this.groupTitleElement(dataGroup);
this.addElement(element);
return element;
}
addElement(element) {
this._content.push(element);
}
/**
* Adds a row of CSS `gridAreaId`s into the grid that is held in this subgrid.
* @param row the field Ids. The width of the row should match the number of columns of the grid. If not an error is thrown.
*/
addRow(row) {
if (row.length !== this.cols) {
throw new Error(`The provided grid layout row '${JSON.stringify(row)}' does not match the number of columns of this subgrid (${this.cols})`);
}
this._grid.push(row);
}
/**
* Converts the provided configuration into data that can be fed into CSS grid layout
*/
finalize() {
this.fillEmptySpace();
this.createGridAreasString();
}
/**
* Fills empty tiles in the grid with blank elements
*/
fillEmptySpace() {
const runningBlanksCount = new IncrementingCounter();
this._grid.forEach(row => {
for (let i = 0; i < row.length; i++) {
if (row[i] !== '') {
continue;
}
const filler = this.fillerElement(runningBlanksCount);
row[i] = filler.gridAreaId;
this._content.push(filler);
}
});
}
/**
* @param field the field whose representation should be created
* @param type the type of the data field
* @returns an object that represents the provided data field in the layout
*/
fieldElement(field, type) {
return { gridAreaId: this.assureUniqueness(field.stringId), type, item: field };
}
/**
* @param fillerCounter the counter that is used to track the number of already created filler elements
* @returns a filler element object with a unique ID. The provided counter is incremented by one.
*/
fillerElement(fillerCounter) {
return { gridAreaId: this.assureUniqueness('blank' + fillerCounter.next()), type: TaskElementType.BLANK };
}
/**
* @param dataGroup the data group whose title element should be created
* @returns an object that represents a title element of the provided data group. The provided counter is incremented by one.
*/
groupTitleElement(dataGroup) {
return {
title: dataGroup.title,
gridAreaId: this.assureUniqueness('group' + this._runningTitleCount.next()),
type: TaskElementType.DATA_GROUP_TITLE
};
}
/**
* Assures that the provided identifier will be unique.
* @param identifier the base for the identifier
* @returns the base identifier, if it already is unique. A unique variation on the base identifier if it is already in use.
*/
assureUniqueness(identifier) {
const alphaNumIdentifier = 'x' + identifier?.replace(/[^0-9a-z]/gi, '');
if (!this._existingIdentifiers.has(alphaNumIdentifier)) {
this._existingIdentifiers.add(alphaNumIdentifier);
return alphaNumIdentifier;
}
let variation;
const counter = new IncrementingCounter();
do {
variation = `x${counter.next()}${alphaNumIdentifier}`;
} while (this._existingIdentifiers.has(variation));
this._existingIdentifiers.add(variation);
return variation;
}
/**
* Joins the grid of element into a string accepted by `[gdAreas]` input property of Angular flex layout
*/
createGridAreasString() {
this.gridAreas = this._grid.map(row => row.join(' ')).join(' | ');
}
/**
* Marks all contained elements as kept and displays them.
*/
displayAllFields() {
this._keptElements = [...this._content];
this._newElements = [];
this._renderedContent$.next(this._keptElements);
}
/**
* Determines which elements from the provided subgrid are contained in this subgrid.
* Marks these elements as kept and displays them. Marks the remaining elements as new.
*
* New elements can be displayed asynchronously over time by calling the
* [renderContentOverTime]{@link Subgrid#renderContentOverTime} method.
* @param subgrid the "previous" subgrid that is used to compute the element "difference"
*/
determineKeptFields(subgrid) {
this._keptElements = [];
this._newElements = [];
this._content.forEach(element => {
if (subgrid.content.some(el => el.gridAreaId === element.gridAreaId)) {
this._keptElements.push(element);
}
else {
this._newElements.push(element);
}
});
this._renderedContent$.next(this._keptElements);
}
/**
* If elements are not sorted into new and kept, marks all elements as new.
* The [determineKeptFields]{@link Subgrid#determineKeptFields} method can be used to mark elements as kept.
*
* Then pushes the new elements with the kept elements into the output array over time as specified by the
* {@link AsyncRenderingConfiguration} provided in the subgrids constructor.
*
* @param callback the function that is called once all new elements were pushed into the output array
* @param first whether this is the first subgrid that si rendered. If this is the first subgrid then on the initial rendering of
* elements a batch of new fields alongside the loader elements is displayed so that some content is immediately available.
* Otherwise The initial batch contains only loader elements. Being first effectively shortens the rendering by one batch, since the
* first loader-only batch is skipped.
*/
renderContentOverTime(callback, first = false) {
if (this._newElements === undefined) {
this._newElements = Array.from(this._content);
this._keptElements = [];
}
this.spreadFieldRenderingOverTime(callback, first ? 1 : 0);
}
spreadFieldRenderingOverTime(callback, iteration = 0) {
this._asyncRenderingTimeout = undefined;
const fieldsInCurrentIteration = this._newElements.slice(0, iteration * this._asyncRenderingConfig.batchSize);
const placeholdersInCurrentIteration = this._newElements.slice(iteration * this._asyncRenderingConfig.batchSize, iteration * this._asyncRenderingConfig.batchSize + this._asyncRenderingConfig.numberOfPlaceholders);
fieldsInCurrentIteration.push(...placeholdersInCurrentIteration.map(field => ({ gridAreaId: field.gridAreaId, type: TaskElementType.LOADER })));
this._renderedContent$.next([...this._keptElements, ...fieldsInCurrentIteration]);
if (this._asyncRenderingConfig.batchSize * iteration < this._newElements.length) {
this._asyncRenderingTimeout = window.setTimeout(() => {
this.spreadFieldRenderingOverTime(callback, iteration + 1);
}, this._asyncRenderingConfig.batchDelay);
}
else {
callback();
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"subgrid.js","sourceRoot":"","sources":["../../../../../../projects/netgrif-components-core/src/lib/task-content/model/subgrid.ts"],"names":[],"mappings":"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","sourcesContent":["import {DatafieldGridLayoutElement} from './datafield-grid-layout-element';\nimport {IncrementingCounter} from '../../utility/incrementing-counter';\nimport {TaskElementType} from './task-content-element-type';\nimport {DataField} from '../../data-fields/models/abstract-data-field';\nimport {FieldTypeResource} from './field-type-resource';\nimport {DataGroup} from '../../resources/interface/data-groups';\nimport {BehaviorSubject} from 'rxjs';\nimport {AsyncRenderingConfiguration} from './async-rendering-configuration';\n\n/**\n * A configuration for one subgrid - a basic layouting unit\n */\nexport class Subgrid {\n    /**\n     * the css `gridAreas` configuration, that determines the layout of the grids content\n     */\n    gridAreas: string;\n    /**\n     * The elements that are contained in the subgrid\n     */\n    protected _content: Array<DatafieldGridLayoutElement> = [];\n    /**\n     * The elements that are contained in the subgrid and have already been rendered to the user\n     */\n    protected _renderedContent$: BehaviorSubject<Array<DatafieldGridLayoutElement>>;\n    /**\n     * A 2D representation of the grid element IDs\n     */\n    protected _grid: Array<Array<string>> = [];\n    /**\n     * Counter to assure element ID uniqueness\n     */\n    protected _runningTitleCount: IncrementingCounter = new IncrementingCounter();\n    /**\n     * Grid area identifiers that are already in use\n     */\n    protected _existingIdentifiers = new Set<string>();\n    protected _asyncRenderingTimeout: number;\n    protected _keptElements: Array<DatafieldGridLayoutElement>;\n    protected _newElements: Array<DatafieldGridLayoutElement>;\n\n    /**\n     * @param subgridId a unique identifier of the subgrid in the task layout\n     * @param cols Number of columns of the subgrid\n     * @param _asyncRenderingConfig configuration object for async rendering of data fields\n     */\n    public constructor(public subgridId: string, public cols: number, protected _asyncRenderingConfig: AsyncRenderingConfiguration) {\n        this._renderedContent$ = new BehaviorSubject<Array<DatafieldGridLayoutElement>>([]);\n    }\n\n    get content(): Array<DatafieldGridLayoutElement> {\n        return this._renderedContent$.value;\n    }\n\n    /**\n     * Completes the underlying stream and clears any running timeouts\n     */\n    public destroy() {\n        this._renderedContent$.complete();\n        if (this._asyncRenderingTimeout !== undefined) {\n            window.clearTimeout(this._asyncRenderingTimeout);\n        }\n    }\n\n    /**\n     * @returns the columns configuration for the grid layout\n     */\n    public getGridColumns(): string {\n        return 'repeat(' + this.cols + ', 1fr)';\n    }\n\n    public getRunningTitleCount(): IncrementingCounter {\n        return this._runningTitleCount;\n    }\n\n    /**\n     * Converts a {@link DataField} into a {@link DatafieldGridLayoutElement} and adds it to the content of this subgrid.\n     *\n     * Beware that this method DOES NOT add the element into the resulting grid. This must be done independently by calling the\n     * [addRow]{@link Subgrid#addRow} method.\n     * @param field the field that should be added to the subgrid\n     * @param type the type of the field\n     * @returns the created grid element\n     */\n    public addField(field: DataField<unknown>, type: FieldTypeResource): DatafieldGridLayoutElement {\n        const element = this.fieldElement(field, type);\n        this.addElement(element);\n        return element;\n    }\n\n    /**\n     * Converts a {@link DataGroup} into a {@link DatafieldGridLayoutElement} and adds it to the content of this subgrid.\n     *\n     * Beware that this method DOES NOT add the element into the resulting grid. This must be done independently by calling the\n     * [addRow]{@link Subgrid#addRow} method.\n     * @param dataGroup the data group whose title should be added to the grid\n     * @returns the created grid element\n     */\n    public addTitle(dataGroup: DataGroup): DatafieldGridLayoutElement {\n        const element = this.groupTitleElement(dataGroup);\n        this.addElement(element);\n        return element;\n    }\n\n    protected addElement(element: DatafieldGridLayoutElement): void {\n        this._content.push(element);\n    }\n\n    /**\n     * Adds a row of CSS `gridAreaId`s into the grid that is held in this subgrid.\n     * @param row the field Ids. The width of the row should match the number of columns of the grid. If not an error is thrown.\n     */\n    public addRow(row: Array<string>): void {\n        if (row.length !== this.cols) {\n            throw new Error(`The provided grid layout row '${JSON.stringify(row)\n            }' does not match the number of columns of this subgrid (${this.cols})`);\n        }\n        this._grid.push(row);\n    }\n\n    /**\n     * Converts the provided configuration into data that can be fed into CSS grid layout\n     */\n    public finalize() {\n        this.fillEmptySpace();\n        this.createGridAreasString();\n    }\n\n    /**\n     * Fills empty tiles in the grid with blank elements\n     */\n    protected fillEmptySpace() {\n        const runningBlanksCount = new IncrementingCounter();\n        this._grid.forEach(row => {\n            for (let i = 0; i < row.length; i++) {\n                if (row[i] !== '') {\n                    continue;\n                }\n                const filler = this.fillerElement(runningBlanksCount);\n                row[i] = filler.gridAreaId;\n                this._content.push(filler);\n            }\n        });\n    }\n\n    /**\n     * @param field the field whose representation should be created\n     * @param type the type of the data field\n     * @returns an object that represents the provided data field in the layout\n     */\n    protected fieldElement(field: DataField<unknown>, type: FieldTypeResource): DatafieldGridLayoutElement {\n        return {gridAreaId: this.assureUniqueness(field.stringId), type, item: field};\n    }\n\n    /**\n     * @param fillerCounter the counter that is used to track the number of already created filler elements\n     * @returns a filler element object with a unique ID. The provided counter is incremented by one.\n     */\n    protected fillerElement(fillerCounter: IncrementingCounter): DatafieldGridLayoutElement {\n        return {gridAreaId: this.assureUniqueness('blank' + fillerCounter.next()), type: TaskElementType.BLANK};\n    }\n\n    /**\n     * @param dataGroup the data group whose title element should be created\n     * @returns an object that represents a title element of the provided data group. The provided counter is incremented by one.\n     */\n    protected groupTitleElement(dataGroup: DataGroup): DatafieldGridLayoutElement {\n        return {\n            title: dataGroup.title,\n            gridAreaId: this.assureUniqueness('group' + this._runningTitleCount.next()),\n            type: TaskElementType.DATA_GROUP_TITLE\n        };\n    }\n\n    /**\n     * Assures that the provided identifier will be unique.\n     * @param identifier the base for the identifier\n     * @returns the base identifier, if it already is unique. A unique variation on the base identifier if it is already in use.\n     */\n    protected assureUniqueness(identifier: string): string {\n        const alphaNumIdentifier = 'x' + identifier?.replace(/[^0-9a-z]/gi, '');\n        if (!this._existingIdentifiers.has(alphaNumIdentifier)) {\n            this._existingIdentifiers.add(alphaNumIdentifier);\n            return alphaNumIdentifier;\n        }\n        let variation;\n        const counter = new IncrementingCounter();\n        do {\n            variation = `x${counter.next()}${alphaNumIdentifier}`;\n        } while (this._existingIdentifiers.has(variation));\n        this._existingIdentifiers.add(variation);\n        return variation;\n    }\n\n    /**\n     * Joins the grid of element into a string accepted by `[gdAreas]` input property of Angular flex layout\n     */\n    protected createGridAreasString(): void {\n        this.gridAreas = this._grid.map(row => row.join(' ')).join(' | ');\n    }\n\n    /**\n     * Marks all contained elements as kept and displays them.\n     */\n    public displayAllFields(): void {\n        this._keptElements = [...this._content];\n        this._newElements = [];\n        this._renderedContent$.next(this._keptElements);\n    }\n\n    /**\n     * Determines which elements from the provided subgrid are contained in this subgrid.\n     * Marks these elements as kept and displays them. Marks the remaining elements as new.\n     *\n     * New elements can be displayed asynchronously over time by calling the\n     * [renderContentOverTime]{@link Subgrid#renderContentOverTime} method.\n     * @param subgrid the \"previous\" subgrid that is used to compute the element \"difference\"\n     */\n    public determineKeptFields(subgrid: Subgrid): void {\n        this._keptElements = [];\n        this._newElements = [];\n\n        this._content.forEach(element => {\n            if (subgrid.content.some(el => el.gridAreaId === element.gridAreaId)) {\n                this._keptElements.push(element);\n            } else {\n                this._newElements.push(element);\n            }\n        });\n\n        this._renderedContent$.next(this._keptElements);\n    }\n\n    /**\n     * If elements are not sorted into new and kept, marks all elements as new.\n     * The [determineKeptFields]{@link Subgrid#determineKeptFields} method can be used to mark elements as kept.\n     *\n     * Then pushes the new elements with the kept elements into the output array over time as specified by the\n     * {@link AsyncRenderingConfiguration} provided in the subgrids constructor.\n     *\n     * @param callback the function that is called once all new elements were pushed into the output array\n     * @param first whether this is the first subgrid that si rendered. If this is the first subgrid then on the initial rendering of\n     * elements a batch of new fields alongside the loader elements is displayed so that some content is immediately available.\n     * Otherwise The initial batch contains only loader elements. Being first effectively shortens the rendering by one batch, since the\n     * first loader-only batch is skipped.\n     */\n    public renderContentOverTime(callback: () => void, first= false) {\n        if (this._newElements === undefined) {\n            this._newElements = Array.from(this._content);\n            this._keptElements = [];\n        }\n        this.spreadFieldRenderingOverTime(callback, first ? 1 : 0);\n    }\n\n    protected spreadFieldRenderingOverTime(callback: () => void, iteration = 0) {\n        this._asyncRenderingTimeout = undefined;\n        const fieldsInCurrentIteration = this._newElements.slice(0, iteration * this._asyncRenderingConfig.batchSize);\n        const placeholdersInCurrentIteration = this._newElements.slice(iteration * this._asyncRenderingConfig.batchSize,\n            iteration * this._asyncRenderingConfig.batchSize + this._asyncRenderingConfig.numberOfPlaceholders);\n\n        fieldsInCurrentIteration.push(\n            ...placeholdersInCurrentIteration.map(field => ({gridAreaId: field.gridAreaId, type: TaskElementType.LOADER})));\n\n        this._renderedContent$.next([...this._keptElements, ...fieldsInCurrentIteration]);\n        if (this._asyncRenderingConfig.batchSize * iteration < this._newElements.length) {\n            this._asyncRenderingTimeout = window.setTimeout(() => {\n                this.spreadFieldRenderingOverTime(callback, iteration + 1);\n            }, this._asyncRenderingConfig.batchDelay);\n        } else {\n            callback();\n        }\n    }\n}\n"]}