@sankhyalabs/core 1.0.42 → 1.0.43

package/dist/dataunit/DataUnit.js

@@ -1,279 +1,279 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { convertType } from "./metadata/DataType.js";
-import { DataUnitAction, Action } from "./state/action/DataUnitAction.js";
-import StateManager from "./state/StateManager.js";
-import { HistReducer, canRedo, canUndo } from "./state/HistReducer.js";
-import { UnitMetadataReducer, getField, getMetadata } from "./state/slice/UnitMetadataSlice.js";
-import { RecordsReducer } from "./state/slice/RecordsSlice.js";
-import { SelectionReducer, getSelection, hasNext, hasPrevious } from "./state/slice/SelectionSlice.js";
-import { ChangesReducer, isDirty, getChangesToSave } from "./state/slice/ChangesSlice.js";
-import { RemovedRecordsReducer } from "./state/slice/RemovedRecordsSlice.js";
-import { AddedRecordsReducer, prepareAddedRecordId } from "./state/slice/AddedRecordsSlice.js";
-import { CurrentRecordsReducer, getCurrentRecords, getFieldValue } from "./state/slice/CurrentRecordsSlice.js";
-export default class DataUnit {
-    constructor(name) {
-        this._name = name;
-        this._stateManager = new StateManager([
-            HistReducer,
-            UnitMetadataReducer,
-            RecordsReducer,
-            RemovedRecordsReducer,
-            AddedRecordsReducer,
-            SelectionReducer,
-            ChangesReducer,
-            CurrentRecordsReducer
-        ]);
-        this._observers = [];
-        this._filterProviders = [];
-        this._sortingProvider = undefined;
-        this._interceptors = [];
-    }
-    get name() {
-        return this._name;
-    }
-    // Métodos privados
-    validateAndTypeValue(fieldName, newValue) {
-        //FIXME: Validações devem ser feitas aqui
-        const descriptor = this.getField(fieldName);
-        return descriptor ? convertType(descriptor.dataType, newValue) : newValue;
-    }
-    getFilters() {
-        let filters = undefined;
-        this._filterProviders.forEach(p => {
-            const f = p.getFilter(this.name);
-            if (f) {
-                filters = (filters || []).concat(f);
-            }
-        });
-        return filters;
-    }
-    getSort() {
-        return this._sortingProvider ? this._sortingProvider.getSort(this._name) : undefined;
-    }
-    // Loaders
-    loadMetadata() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.dispatchAction(Action.LOADING_METADATA);
-            return new Promise((resolve, fail) => {
-                if (this.metadataLoader) {
-                    this.metadataLoader(this).then(metadata => {
-                        this.metadata = metadata;
-                        resolve(this.metadata);
-                    }).catch(error => fail(error));
-                }
-            });
-        });
-    }
-    loadData() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.dispatchAction(Action.LOADING_DATA);
-            return new Promise((resolve, fail) => {
-                if (this.dataLoader) {
-                    const sort = this.getSort();
-                    const filters = this.getFilters();
-                    this.dataLoader(this, sort, filters).then(records => {
-                        this.records = records;
-                        resolve(this.records);
-                    }).catch(error => fail(error));
-                }
-            });
-        });
-    }
-    saveData() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const changes = getChangesToSave(this._name, this._stateManager);
-            if (changes.length > 0) {
-                this.dispatchAction(Action.SAVING_DATA);
-                return new Promise((resolve, fail) => {
-                    if (this.saveLoader) {
-                        this.saveLoader(this, changes).then(records => this.dispatchAction(Action.DATA_SAVED, { changes, records })).catch(error => fail(error));
-                    }
-                });
-            }
-            return Promise.resolve();
-        });
-    }
-    removeSelectedRecords(buffered = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const selection = getSelection(this._stateManager);
-            if (selection) {
-                return this.removeRecords(selection, buffered);
-            }
-            return Promise.resolve(selection);
-        });
-    }
-    removeRecords(records, buffered = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (records) {
-                if (buffered || !this.removeLoader) {
-                    this.dispatchAction(Action.RECORDS_REMOVED, { records, buffered: true });
-                }
-                else {
-                    this.dispatchAction(Action.REMOVING_RECORDS);
-                    return new Promise((resolve, fail) => {
-                        if (this.removeLoader) {
-                            this.removeLoader(this, records).then(records => {
-                                this.dispatchAction(Action.RECORDS_REMOVED, { records, buffered: false });
-                                resolve(records);
-                            }).catch(error => fail(error));
-                        }
-                    });
-                }
-            }
-            return Promise.resolve(records);
-        });
-    }
-    // API
-    valueFromString(fieldName, value) {
-        const descriptor = this.getField(fieldName);
-        return descriptor ? convertType(descriptor.dataType, value) : value;
-    }
-    addInterceptor(interceptor) {
-        this._interceptors.push(interceptor);
-    }
-    addFilterProvider(provider) {
-        this._filterProviders.push(provider);
-    }
-    set sortingProvider(provider) {
-        this._sortingProvider = provider;
-    }
-    set metadata(md) {
-        this.dispatchAction(Action.METADATA_LOADED, md);
-    }
-    get metadata() {
-        return getMetadata(this._stateManager);
-    }
-    set records(r) {
-        this.dispatchAction(Action.DATA_LOADED, r);
-    }
-    get records() {
-        const records = getCurrentRecords(this._stateManager);
-        return records ? Array.from(records.values()) : [];
-    }
-    getField(fieldName) {
-        return getField(this._stateManager, fieldName);
-    }
-    addRecord() {
-        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]));
-    }
-    copySelected() {
-        const selectedRecords = this.getSelectedRecords();
-        if (selectedRecords) {
-            this.dispatchAction(Action.RECORDS_COPIED, prepareAddedRecordId(this._stateManager, selectedRecords));
-        }
-    }
-    getFieldValue(fieldName) {
-        return getFieldValue(this._stateManager, fieldName);
-    }
-    setFieldValue(fieldName, newValue, records) {
-        const typedValue = this.validateAndTypeValue(fieldName, newValue);
-        const currentValue = this.getFieldValue(fieldName);
-        if (currentValue !== typedValue) {
-            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records });
-        }
-    }
-    getSelection() {
-        return getSelection(this._stateManager);
-    }
-    setSelection(selection) {
-        this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection });
-    }
-    setSelectionByIndex(selection) {
-        this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection });
-    }
-    getSelectedRecords() {
-        const selection = this.getSelection();
-        if (selection) {
-            const currentRecords = this.records;
-            return currentRecords === null || currentRecords === void 0 ? void 0 : currentRecords.filter(r => selection.includes(r.__record__id__));
-        }
-    }
-    nextRecord() {
-        this.dispatchAction(Action.NEXT_SELECTED);
-    }
-    previousRecord() {
-        this.dispatchAction(Action.PREVIOUS_SELECTED);
-    }
-    cancelEdition() {
-        this.dispatchAction(Action.EDITION_CANCELED);
-    }
-    isDirty() {
-        return isDirty(this._stateManager);
-    }
-    hasNext() {
-        return hasNext(this._stateManager);
-    }
-    hasPrevious() {
-        return hasPrevious(this._stateManager);
-    }
-    canUndo() {
-        return canUndo(this._stateManager);
-    }
-    canRedo() {
-        return canRedo(this._stateManager);
-    }
-    undo() {
-        this.dispatchAction(Action.CHANGE_UNDONE);
-    }
-    redo() {
-        this.dispatchAction(Action.CHANGE_REDONE);
-    }
-    toString() {
-        return this.name;
-    }
-    // Actions / State manager
-    dispatchAction(actionType, payload) {
-        var _a;
-        let action = new DataUnitAction(actionType, payload);
-        (_a = this._interceptors) === null || _a === void 0 ? void 0 : _a.forEach(interceptor => {
-            if (action) {
-                action = interceptor.interceptAction(action);
-            }
-        });
-        if (action) {
-            this._stateManager.process(action);
-            this._observers.forEach(f => f(action));
-        }
-    }
-    subscribe(observer) {
-        this._observers.push(observer);
-    }
-    unsubscribe(observer) {
-        this._observers = this._observers.filter(f => f !== observer);
-    }
-}
-export var ChangeOperation;
-(function (ChangeOperation) {
-    ChangeOperation["INSERT"] = "INSERT";
-    ChangeOperation["UPDATE"] = "UPDATE";
-    ChangeOperation["DELETE"] = "DELETE";
-})(ChangeOperation || (ChangeOperation = {}));
-export class Change {
-    constructor(dataUnit, record, updates, operation) {
-        this.dataUnit = dataUnit;
-        this.record = record;
-        this.updatingFields = updates;
-        this._operation = operation;
-    }
-    get operation() {
-        return this._operation.toString();
-    }
-    isInsert() {
-        return this._operation === ChangeOperation.INSERT;
-    }
-    isDelete() {
-        return this._operation === ChangeOperation.DELETE;
-    }
-    isUpdate() {
-        return this._operation === ChangeOperation.UPDATE;
-    }
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { convertType } from "./metadata/DataType.js";
+import { DataUnitAction, Action } from "./state/action/DataUnitAction.js";
+import StateManager from "./state/StateManager.js";
+import { HistReducer, canRedo, canUndo } from "./state/HistReducer.js";
+import { UnitMetadataReducer, getField, getMetadata } from "./state/slice/UnitMetadataSlice.js";
+import { RecordsReducer } from "./state/slice/RecordsSlice.js";
+import { SelectionReducer, getSelection, hasNext, hasPrevious } from "./state/slice/SelectionSlice.js";
+import { ChangesReducer, isDirty, getChangesToSave } from "./state/slice/ChangesSlice.js";
+import { RemovedRecordsReducer } from "./state/slice/RemovedRecordsSlice.js";
+import { AddedRecordsReducer, prepareAddedRecordId } from "./state/slice/AddedRecordsSlice.js";
+import { CurrentRecordsReducer, getCurrentRecords, getFieldValue } from "./state/slice/CurrentRecordsSlice.js";
+export default class DataUnit {
+    constructor(name) {
+        this._name = name;
+        this._stateManager = new StateManager([
+            HistReducer,
+            UnitMetadataReducer,
+            RecordsReducer,
+            RemovedRecordsReducer,
+            AddedRecordsReducer,
+            SelectionReducer,
+            ChangesReducer,
+            CurrentRecordsReducer
+        ]);
+        this._observers = [];
+        this._filterProviders = [];
+        this._sortingProvider = undefined;
+        this._interceptors = [];
+    }
+    get name() {
+        return this._name;
+    }
+    // Métodos privados
+    validateAndTypeValue(fieldName, newValue) {
+        //FIXME: Validações devem ser feitas aqui
+        const descriptor = this.getField(fieldName);
+        return descriptor ? convertType(descriptor.dataType, newValue) : newValue;
+    }
+    getFilters() {
+        let filters = undefined;
+        this._filterProviders.forEach(p => {
+            const f = p.getFilter(this.name);
+            if (f) {
+                filters = (filters || []).concat(f);
+            }
+        });
+        return filters;
+    }
+    getSort() {
+        return this._sortingProvider ? this._sortingProvider.getSort(this._name) : undefined;
+    }
+    // Loaders
+    loadMetadata() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.dispatchAction(Action.LOADING_METADATA);
+            return new Promise((resolve, fail) => {
+                if (this.metadataLoader) {
+                    this.metadataLoader(this).then(metadata => {
+                        this.metadata = metadata;
+                        resolve(this.metadata);
+                    }).catch(error => fail(error));
+                }
+            });
+        });
+    }
+    loadData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.dispatchAction(Action.LOADING_DATA);
+            return new Promise((resolve, fail) => {
+                if (this.dataLoader) {
+                    const sort = this.getSort();
+                    const filters = this.getFilters();
+                    this.dataLoader(this, sort, filters).then(records => {
+                        this.records = records;
+                        resolve(this.records);
+                    }).catch(error => fail(error));
+                }
+            });
+        });
+    }
+    saveData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const changes = getChangesToSave(this._name, this._stateManager);
+            if (changes.length > 0) {
+                this.dispatchAction(Action.SAVING_DATA);
+                return new Promise((resolve, fail) => {
+                    if (this.saveLoader) {
+                        this.saveLoader(this, changes).then(records => this.dispatchAction(Action.DATA_SAVED, { changes, records })).catch(error => fail(error));
+                    }
+                });
+            }
+            return Promise.resolve();
+        });
+    }
+    removeSelectedRecords(buffered = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const selection = getSelection(this._stateManager);
+            if (selection) {
+                return this.removeRecords(selection, buffered);
+            }
+            return Promise.resolve(selection);
+        });
+    }
+    removeRecords(records, buffered = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (records) {
+                if (buffered || !this.removeLoader) {
+                    this.dispatchAction(Action.RECORDS_REMOVED, { records, buffered: true });
+                }
+                else {
+                    this.dispatchAction(Action.REMOVING_RECORDS);
+                    return new Promise((resolve, fail) => {
+                        if (this.removeLoader) {
+                            this.removeLoader(this, records).then(records => {
+                                this.dispatchAction(Action.RECORDS_REMOVED, { records, buffered: false });
+                                resolve(records);
+                            }).catch(error => fail(error));
+                        }
+                    });
+                }
+            }
+            return Promise.resolve(records);
+        });
+    }
+    // API
+    valueFromString(fieldName, value) {
+        const descriptor = this.getField(fieldName);
+        return descriptor ? convertType(descriptor.dataType, value) : value;
+    }
+    addInterceptor(interceptor) {
+        this._interceptors.push(interceptor);
+    }
+    addFilterProvider(provider) {
+        this._filterProviders.push(provider);
+    }
+    set sortingProvider(provider) {
+        this._sortingProvider = provider;
+    }
+    set metadata(md) {
+        this.dispatchAction(Action.METADATA_LOADED, md);
+    }
+    get metadata() {
+        return getMetadata(this._stateManager);
+    }
+    set records(r) {
+        this.dispatchAction(Action.DATA_LOADED, r);
+    }
+    get records() {
+        const records = getCurrentRecords(this._stateManager);
+        return records ? Array.from(records.values()) : [];
+    }
+    getField(fieldName) {
+        return getField(this._stateManager, fieldName);
+    }
+    addRecord() {
+        this.dispatchAction(Action.RECORDS_ADDED, prepareAddedRecordId(this._stateManager, [{}]));
+    }
+    copySelected() {
+        const selectedRecords = this.getSelectedRecords();
+        if (selectedRecords) {
+            this.dispatchAction(Action.RECORDS_COPIED, prepareAddedRecordId(this._stateManager, selectedRecords));
+        }
+    }
+    getFieldValue(fieldName) {
+        return getFieldValue(this._stateManager, fieldName);
+    }
+    setFieldValue(fieldName, newValue, records) {
+        const typedValue = this.validateAndTypeValue(fieldName, newValue);
+        const currentValue = this.getFieldValue(fieldName);
+        if (currentValue !== typedValue) {
+            this.dispatchAction(Action.DATA_CHANGED, { [fieldName]: typedValue, records });
+        }
+    }
+    getSelection() {
+        return getSelection(this._stateManager);
+    }
+    setSelection(selection) {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "id", selection });
+    }
+    setSelectionByIndex(selection) {
+        this.dispatchAction(Action.SELECTION_CHANGED, { type: "index", selection });
+    }
+    getSelectedRecords() {
+        const selection = this.getSelection();
+        if (selection) {
+            const currentRecords = this.records;
+            return currentRecords === null || currentRecords === void 0 ? void 0 : currentRecords.filter(r => selection.includes(r.__record__id__));
+        }
+    }
+    nextRecord() {
+        this.dispatchAction(Action.NEXT_SELECTED);
+    }
+    previousRecord() {
+        this.dispatchAction(Action.PREVIOUS_SELECTED);
+    }
+    cancelEdition() {
+        this.dispatchAction(Action.EDITION_CANCELED);
+    }
+    isDirty() {
+        return isDirty(this._stateManager);
+    }
+    hasNext() {
+        return hasNext(this._stateManager);
+    }
+    hasPrevious() {
+        return hasPrevious(this._stateManager);
+    }
+    canUndo() {
+        return canUndo(this._stateManager);
+    }
+    canRedo() {
+        return canRedo(this._stateManager);
+    }
+    undo() {
+        this.dispatchAction(Action.CHANGE_UNDONE);
+    }
+    redo() {
+        this.dispatchAction(Action.CHANGE_REDONE);
+    }
+    toString() {
+        return this.name;
+    }
+    // Actions / State manager
+    dispatchAction(actionType, payload) {
+        var _a;
+        let action = new DataUnitAction(actionType, payload);
+        (_a = this._interceptors) === null || _a === void 0 ? void 0 : _a.forEach(interceptor => {
+            if (action) {
+                action = interceptor.interceptAction(action);
+            }
+        });
+        if (action) {
+            this._stateManager.process(action);
+            this._observers.forEach(f => f(action));
+        }
+    }
+    subscribe(observer) {
+        this._observers.push(observer);
+    }
+    unsubscribe(observer) {
+        this._observers = this._observers.filter(f => f !== observer);
+    }
+}
+export var ChangeOperation;
+(function (ChangeOperation) {
+    ChangeOperation["INSERT"] = "INSERT";
+    ChangeOperation["UPDATE"] = "UPDATE";
+    ChangeOperation["DELETE"] = "DELETE";
+})(ChangeOperation || (ChangeOperation = {}));
+export class Change {
+    constructor(dataUnit, record, updates, operation) {
+        this.dataUnit = dataUnit;
+        this.record = record;
+        this.updatingFields = updates;
+        this._operation = operation;
+    }
+    get operation() {
+        return this._operation.toString();
+    }
+    isInsert() {
+        return this._operation === ChangeOperation.INSERT;
+    }
+    isDelete() {
+        return this._operation === ChangeOperation.DELETE;
+    }
+    isUpdate() {
+        return this._operation === ChangeOperation.UPDATE;
+    }
+}
 //# sourceMappingURL=DataUnit.js.map

package/dist/dataunit/metadata/DataType.d.ts

@@ -1,9 +1,9 @@
-export declare enum DataType {
-    NUMBER = "NUMBER",
-    DATE = "DATE",
-    TEXT = "TEXT",
-    BOOLEAN = "BOOLEAN",
-    OBJECT = "OBJECT"
-}
-export declare const convertType: (dataType: DataType, value: any) => any;
-export declare const toString: (dataType: DataType, value: any) => string;
+export declare enum DataType {
+    NUMBER = "NUMBER",
+    DATE = "DATE",
+    TEXT = "TEXT",
+    BOOLEAN = "BOOLEAN",
+    OBJECT = "OBJECT"
+}
+export declare const convertType: (dataType: DataType, value: any) => any;
+export declare const toString: (dataType: DataType, value: any) => string;

package/dist/dataunit/metadata/DataType.js

@@ -1,37 +1,37 @@
-export var DataType;
-(function (DataType) {
-    DataType["NUMBER"] = "NUMBER";
-    DataType["DATE"] = "DATE";
-    DataType["TEXT"] = "TEXT";
-    DataType["BOOLEAN"] = "BOOLEAN";
-    DataType["OBJECT"] = "OBJECT";
-})(DataType || (DataType = {}));
-export const convertType = (dataType, value) => {
-    if (value === undefined || value === null) {
-        return value;
-    }
-    switch (dataType) {
-        case DataType.NUMBER:
-            return value === "" || isNaN(value) ? null : Number(value);
-        case DataType.OBJECT:
-            return typeof value === "string" ? JSON.parse(value) : value;
-        case DataType.BOOLEAN:
-            return Boolean(value);
-        case DataType.DATE:
-            return new Date(value.toString());
-        default:
-            return value;
-    }
-};
-export const toString = (dataType, value) => {
-    if (value === undefined || value === null) {
-        return value;
-    }
-    if (dataType === DataType.OBJECT) {
-        return JSON.stringify(value);
-    }
-    else {
-        return value.toString();
-    }
-};
+export var DataType;
+(function (DataType) {
+    DataType["NUMBER"] = "NUMBER";
+    DataType["DATE"] = "DATE";
+    DataType["TEXT"] = "TEXT";
+    DataType["BOOLEAN"] = "BOOLEAN";
+    DataType["OBJECT"] = "OBJECT";
+})(DataType || (DataType = {}));
+export const convertType = (dataType, value) => {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    switch (dataType) {
+        case DataType.NUMBER:
+            return value === "" || isNaN(value) ? null : Number(value);
+        case DataType.OBJECT:
+            return typeof value === "string" ? JSON.parse(value) : value;
+        case DataType.BOOLEAN:
+            return Boolean(value);
+        case DataType.DATE:
+            return new Date(value.toString());
+        default:
+            return value;
+    }
+};
+export const toString = (dataType, value) => {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    if (dataType === DataType.OBJECT) {
+        return JSON.stringify(value);
+    }
+    else {
+        return value.toString();
+    }
+};
 //# sourceMappingURL=DataType.js.map