native-document 1.0.76 → 1.0.78

package/src/components/stepper/StepperStep.js

@@ -0,0 +1,103 @@
+import BaseComponent from "../BaseComponent";
+import { $ } from '../../../index';
+
+export default function StepperStep(label, config = {}) {
+    if(!(this instanceof StepperStep)) {
+        return new StepperStep(label, config);
+    }
+
+    this.$description = {
+        icon: null,
+        label: label,
+        description: null,
+        content: null,
+        status: $('pending'),
+        optional: $(false),
+        disabled: $(false),
+        completed: $(false),
+        error: $(false),
+        data: null,
+        render: null,
+        validator: null,
+        key: null,
+        ...config
+    };
+}
+
+BaseComponent.extends(StepperStep);
+
+StepperStep.defaultTemplate = null;
+
+StepperStep.use = function(template) {
+    StepperStep.defaultTemplate = template.stepperStep;
+};
+
+StepperStep.prototype.icon = function(icon) {
+    this.$description.icon = icon;
+    return this;
+};
+
+StepperStep.prototype.label = function(label) {
+    this.$description.label = label;
+    return this;
+};
+
+StepperStep.prototype.description = function(description) {
+    this.$description.description = description;
+    return this;
+};
+
+StepperStep.prototype.content = function(content) {
+    this.$description.content = content;
+    return this;
+};
+
+StepperStep.prototype.status = function(status) {
+    this.$description.status.set(status);
+    return this;
+};
+
+StepperStep.prototype.optional = function(optional = true) {
+    this.$description.optional.set(optional);
+    return this;
+};
+
+StepperStep.prototype.disabled = function(disabled = true) {
+    this.$description.disabled.set(disabled);
+    return this;
+};
+
+StepperStep.prototype.completed = function(completed = true) {
+    this.$description.completed.set(completed);
+    this.$description.status.set(completed ? 'completed' : 'pending');
+    return this;
+};
+
+StepperStep.prototype.error = function(error = true) {
+    this.$description.error.set(error);
+    this.$description.status.set(error ? 'error' : 'pending');
+    return this;
+};
+
+StepperStep.prototype.data = function(data) {
+    this.$description.data = data;
+    return this;
+};
+
+StepperStep.prototype.key = function(key) {
+    this.$description.key = key;
+    return this;
+};
+
+StepperStep.prototype.getKey = function() {
+    return this.$description.key;
+};
+
+StepperStep.prototype.validator = function(validatorFn) {
+    this.$description.validator = validatorFn;
+    return this;
+};
+
+StepperStep.prototype.validate = function() {
+    return true;
+};

package/src/components/stepper/index.js

@@ -0,0 +1,8 @@
+import Stepper from "./Stepper";
+import StepperStep from "./StepperStep";
+
+
+export {
+    Stepper,
+    StepperStep
+}

package/src/components/switch/Switch.js

@@ -0,0 +1,99 @@
+import BaseComponent from "../BaseComponent";
+import EventEmitter from "../../../src/core/utils/EventEmitter";
+
+function Switch(config = {}) {
+    if (!(this instanceof Switch)) {
+        return new Switch(config);
+    }
+
+    this.$description = {
+
+    };
+}
+
+BaseComponent.extends(Switch, EventEmitter);
+
+// Theming
+Switch.defaultTemplate = null;
+Switch.use = function(template) {
+
+};
+
+Switch.prototype.model = function(value) {};
+Switch.prototype.value = function() {};
+
+Switch.prototype.label = function(label) {};
+Switch.prototype.labelPosition = function(position) {};
+
+Switch.prototype.variant = function(name) {
+    this.$description.variant = name;
+    return this;
+};
+Switch.prototype.primary = function() {
+    return this.variant('primary');
+};
+Switch.prototype.secondary = function() {
+    return this.variant('secondary');
+};
+Switch.prototype.danger = function() {
+    return this.variant('danger');
+};
+Switch.prototype.success = function() {
+    return this.variant('success');
+};
+Switch.prototype.warning = function() {
+    return this.variant('warning');
+};
+Switch.prototype.ghost = function() {
+    return this.variant('ghost');
+};
+Switch.prototype.link = function() {
+    return this.variant('link');
+};
+Switch.prototype.outline = function() {
+    this.$description.outline = true;
+    return this;
+};
+
+Switch.prototype.disabled = function(condition = true) {
+    this.$description.disabled = condition;
+    return this;
+};
+Switch.prototype.loading = function(isLoading = true) {
+    this.$description.loading = isLoading;
+    return this;
+};
+Switch.prototype.readonly = function(condition = true) {
+    this.$description.readonly = condition;
+    return this;
+};
+
+Switch.prototype.icon = function(onIcon, offIcon) {};
+
+Switch.prototype.toggle = function() {};
+Switch.prototype.on = function() {};
+Switch.prototype.off = function() {};
+
+Switch.prototype.onChange = function(handler) {
+    this.on('change', handler);
+    return this;
+};
+Switch.prototype.onOn = function(handler) {
+    this.on('on', handler);
+    return this;
+};
+Switch.prototype.onOff = function(handler) {
+    this.on('off', handler);
+    return this;
+};
+
+// Render
+Switch.prototype.render = function(renderFn) {
+    this.$description.render = renderFn;
+    return this;
+};
+
+Switch.prototype.$build = function() {
+
+};
+Switch.prototype.toNdElement = function() {};

package/src/components/table/SimpleTable.js

@@ -1,6 +1,6 @@
 import Column from "./Column";
 import ColumnGroup from "./ColumnGroup";
-import {Table, TFoot, TRow} from "../../../elements";
+import { Table, TFoot, TRow } from "../../../elements";
 import DataTable from "./DataTable";
 
 
@@ -122,37 +122,6 @@ SimpleTable.prototype.buildTable = function(slots = {}) {
     ]);
 };
 
-SimpleTable.prototype.build = function() {
-    const header = [];
-    if(this.$description.hasGroups) {
-        const firstRow = [];
-        const secondRow = [];
-
-        this.$description.header.forEach(columnOrGroup => {
-            if(columnOrGroup.isGroup) {
-                const columns = columnOrGroup.columns();
-                firstRow.push(columnOrGroup.buildHeader());
-                secondRow.push(columns.map(column => THeadCell({}, column.buildHeader())));
-            } else {
-                firstRow.push(columnOrGroup.buildHeader(2));
-            }
-        });
-
-        header.push(TRow(firstRow));
-        header.push(TRow(secondRow));
-    } else {
-        header.push(TRow(
-            this.$description.columns.map(column => column.buildHeader())
-        ));
-    }
-
-    return this.buildTable({ headerRows: header });
-};
-
-SimpleTable.prototype.toNdElement = function() {
-    return this.build();
-};
-
 SimpleTable.prototype.onClick = function(callback) {
     this.$description.onClick = callback;
 };
@@ -182,3 +151,38 @@ DataTable.prototype.isRowExpanded = function(row) {
     // TODO: implement this action
     return this;
 };
+
+
+//
+
+
+SimpleTable.prototype.$build = function() {
+    const header = [];
+    if(this.$description.hasGroups) {
+        const firstRow = [];
+        const secondRow = [];
+
+        this.$description.header.forEach(columnOrGroup => {
+            if(columnOrGroup.isGroup) {
+                const columns = columnOrGroup.columns();
+                firstRow.push(columnOrGroup.buildHeader());
+                secondRow.push(columns.map(column => THeadCell({}, column.buildHeader())));
+            } else {
+                firstRow.push(columnOrGroup.buildHeader(2));
+            }
+        });
+
+        header.push(TRow(firstRow));
+        header.push(TRow(secondRow));
+    } else {
+        header.push(TRow(
+            this.$description.columns.map(column => column.buildHeader())
+        ));
+    }
+
+    return this.buildTable({ headerRows: header });
+};
+
+SimpleTable.prototype.toNdElement = function() {
+    return this.$build();
+};

package/src/components/tabs/Tabs.js

@@ -0,0 +1,110 @@
+import BaseComponent from "../BaseComponent";
+import EventEmitter from "../../../src/core/utils/EventEmitter";
+
+
+export default function Tabs(config = {}) {
+    if(!(this instanceof Tabs)) {
+        return new Tabs();
+    }
+    BaseComponent.apply(this);
+    this.$description = {
+        active: $(''),
+        tabs: {},
+        ...config,
+    };
+
+    this.tabsMap = {};
+}
+
+BaseComponent.extends(Tabs, EventEmitter);
+
+Tabs.defaultTemplate = null;
+Tabs.defaultTabTemplate = null;
+Tabs.defaultNavigationBarTemplate = null;
+
+Tabs.use = function(template) {};
+
+Tabs.prototype.activateTab = function(key) {};
+Tabs.prototype.closeTab = function(key) {};
+
+Tabs.prototype.tab = function(label, content, key) {
+    this.$description.tabs[key] = { label, content };
+    this.tabsMap[key] = content;
+    return this;
+};
+Tabs.prototype.tabs = function(tabs) {
+    for(const item of tabs) {
+        this.tab(item.label, item.content, item.key);
+    }
+    return this;
+};
+Tabs.prototype.removeTab = function(key) {
+    delete this.$description.tabs[key];
+    delete this.tabsMap[key];
+    // Todo: remove tab from Match element
+    this.active(Object.keys(this.$description.tabs)[0]);
+    return this;
+};
+
+Tabs.prototype.active = function(key) {
+    this.$description.active.set(key);
+};
+Tabs.prototype.defaultActive = function(key) {};
+Tabs.prototype.getActive = function() {};
+
+Tabs.prototype.navigationBarPosition = function(position) {
+    this.$description.navigationBarPosition = position;
+    return this;
+};
+Tabs.prototype.navigationBarAtLeft = function() {
+    return this.navigationBarPosition('left');
+};
+Tabs.prototype.navigationBarAtRight = function() {
+    return this.navigationBarPosition('right');
+};
+Tabs.prototype.navigationBarAtTop = function() {
+    return this.navigationBarPosition('top');
+}
+Tabs.prototype.navigationBarAsDock = function() {
+    return this.navigationBarPosition('dock');
+};
+
+// Events
+Tabs.prototype.onChange = function(handler) {
+    this.on('change', handler);
+    return this;
+};
+Tabs.prototype.onBeforeChange = function(handler) {
+    this.on('beforeChange', handler);
+    return this;
+};
+Tabs.prototype.onTabClick = function(handler) {
+    this.on('tabClick', handler);
+    return this;
+};
+Tabs.prototype.onTabClose = function(handler) {
+    this.on('tabClose', handler);
+    return this;
+};
+
+
+Tabs.prototype.renderTab = function(renderFn) {
+    this.$description.renderTab = renderFn;
+    return this;
+};
+Tabs.prototype.renderNavigationBar = function(renderFn) {
+    return this.$description.renderNavigationBar = renderFn;
+};
+
+Tabs.prototype.layout = function(layoutFn) {
+    this.$description.layout = layoutFn;
+    return this;
+};
+
+Tabs.prototype.$build = function() {
+
+};
+
+Tabs.prototype.toNdElement = function() {
+
+};

package/src/components/tabs/index.js

@@ -0,0 +1,6 @@
+import Tabs from './Tabs'
+
+
+export {
+    Tabs
+}

package/src/components/toast/Toast.js

@@ -0,0 +1,129 @@
+import BaseComponent from "../BaseComponent";
+import EventEmitter from "../../../src/core/utils/EventEmitter";
+
+export default function Toast(message, config = {}) {
+    if (!(this instanceof Toast)) {
+        return new Toast(message, config);
+    }
+
+    this.$description = {
+        type: null,
+        title: null,
+        content: null,
+        icon: null,
+        showIcon: true,
+        duration: 3000,
+        closable: true,
+        pauseOnHover: true,
+        position: 'top-right',
+        actions: [],
+        render: null,
+        ...config
+    };
+}
+
+BaseComponent.extends(Toast, EventEmitter);
+
+Toast.use = function(template) {};
+Toast.defaultTemplate = null;
+
+// Types
+Toast.prototype.type = function(type) {
+    this.$description.type = type;
+    return this;
+};
+Toast.prototype.info = function() {
+    return this.type('info');
+};
+Toast.prototype.success = function() {
+    return this.type('success');
+};
+Toast.prototype.warning = function() {
+    return this.type('warning');
+};
+Toast.prototype.error = function() {
+    return this.type('error');
+};
+
+
+Toast.prototype.title = function(title) {
+    this.$description.title = title;
+    return this;
+};
+Toast.prototype.content = function(content) {
+    this.$description.content = content;
+    return this;
+};
+
+Toast.prototype.icon = function(icon) {
+    this.$description.icon = icon;
+    return this;
+};
+Toast.prototype.showIcon = function(show = true) {
+    this.$description.showIcon = show;
+    return this;
+};
+
+// Behavior
+Toast.prototype.duration = function(ms) {
+    this.$description.duration = ms;
+    return this;
+};
+Toast.prototype.closable = function(closable = true) {
+    this.$description.closable = closable;
+    return this;
+};
+Toast.prototype.pauseOnHover = function(pauseOnHover = true) {
+    this.$description.pauseOnHover = pauseOnHover;
+    return this;
+};
+
+// Position
+Toast.prototype.position = function(position) {
+    this.$description.position = position;
+    return this;
+};
+Toast.prototype.atTopStart = function() {
+    return this.position('top-start');
+};
+
+Toast.prototype.atTopEnd = function() {
+    return this.position('top-end');
+};
+Toast.prototype.atBottomStart = function() {
+    return this.position('bottom-start');
+};
+Toast.prototype.atBottomEnd = function() {
+    return this.position('bottom-end');
+};
+Toast.prototype.atTopCenter = function() {
+    return this.position('top-center');
+};
+Toast.prototype.atBottomCenter = function() {
+    return this.position('bottom-center');
+};
+
+Toast.prototype.clearActions = function() {
+    this.$description.actions = [];
+    return this;
+};
+Toast.prototype.action = function(label, handler) {
+    this.$description.actions.push({ label, handler });
+    return this;
+};
+
+Toast.prototype.close = function() {};
+Toast.prototype.onClose = function(handler) {
+    this.on('close', handler);
+    return this;
+};
+
+Toast.prototype.render = function(renderFn) {
+    this.$description.render = renderFn;
+    return this;
+};
+
+Toast.prototype.$build = function() {
+
+};
+Toast.prototype.toNdElement = function() {};

package/src/components/toast/index.js

@@ -0,0 +1,5 @@
+import Toast from './Toast'
+
+export {
+    Toast
+}

package/src/components/tooltip/Tooltip.js

@@ -0,0 +1,98 @@
+/**
+ * Tooltip - Interface
+ */
+
+export default function Tooltip(target, content, config = {}) {
+    if (!(this instanceof Tooltip)) {
+        return new Tooltip(target, content, config);
+    }
+
+    this.$description = {
+        title: null,
+        content: null,
+        position: 'top',
+        trigger: 'hover',
+        target: target,
+        hideDelay: 0,
+        arrow: true,
+        interactive: true,
+        variant: null,
+        ...config,
+    };
+}
+
+Tooltip.use = function(template) {};
+Tooltip.defaultTemplate = null;
+
+Tooltip.prototype.title = function(title) {
+    this.$description.title = title;
+    return this;
+};
+Tooltip.prototype.content = function(content) {
+    this.$description.content = content;
+    return this;
+};
+
+Tooltip.prototype.position = function(position) {
+    this.$description.position = position;
+    return this;
+};
+Tooltip.prototype.top = function() {
+    return this.position('top');
+};
+Tooltip.prototype.bottom = function() {
+    return this.position('bottom');
+};
+Tooltip.prototype.left = function() {
+    return this.position('left');
+};
+Tooltip.prototype.right = function() {
+    return this.position('right');
+};
+Tooltip.prototype.auto = function() {
+    return this.position('auto');
+};
+
+Tooltip.prototype.trigger = function(trigger, target = null) {
+    this.$description.trigger = trigger;
+    this.$description.target = target;
+    return this;
+};
+Tooltip.prototype.showOnHover = function(target = null) {
+    return this.trigger('hover', target);
+};
+Tooltip.prototype.showOnClick = function(target = null) {
+    return this.trigger('click', target);
+};
+Tooltip.prototype.showOnFocus = function(target = null) {
+    return this.trigger('focus', target);
+};
+
+Tooltip.prototype.hideDelay = function(ms) {
+    this.$description.hideDelay = ms;
+    return this;
+};
+Tooltip.prototype.arrow = function(enabled = true) {
+    this.$description.arrow = enabled;
+    return this;
+};
+Tooltip.prototype.interactive = function(isInteractive = true) {
+    this.$description.interactive = isInteractive;
+    return this;
+}
+
+Tooltip.prototype.variant = function(variant) {
+    this.$description.variant = variant;
+    return this;
+};
+
+Tooltip.prototype.show = function() {};
+Tooltip.prototype.hide = function() {};
+
+Tooltip.prototype.render = function(renderFn) {
+    this.$description.render = renderFn;
+    return this;
+};
+
+Tooltip.prototype.$build = function() {};
+Tooltip.prototype.toNdElement = function() {};

package/src/components/tooltip/index.js

@@ -0,0 +1,5 @@
+import Tooltip from './Tooltip';
+
+export {
+    Tooltip
+}

package/src/components/tooltip/prototypes.js

@@ -0,0 +1,6 @@
+
+import {NDElement} from "../../../src/core/wrappers/NDElement";
+
+NDElement.prototype.tooltip = function (tooltip) {
+    // TODO: implement tooltip
+};

package/src/core/data/MemoryManager.js

@@ -1,5 +1,4 @@
-import DebugManager from "../utils/debug-manager";
-import Validator from "../utils/validator";
+import DebugManager from "../../core/utils/debug-manager";
 
 
 const MemoryManager = (function() {

package/src/core/data/Observable.js

@@ -1,6 +1,6 @@
 import ObservableItem from './ObservableItem';
 import MemoryManager from "./MemoryManager";
-import NativeDocumentError from "../errors/NativeDocumentError";
+import NativeDocumentError from "../../core/errors/NativeDocumentError";
 
 /**
  *