polymatica-widget 0.7.0 → 2.0.2

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright 2021 Polymatica
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,6 @@
+# Polymatica Widget SDK
+
+![build: passing](https://raw.githubusercontent.com/git@gitlab.ptnl.moscow:constructor/platform/polymatica-widget/master/badges/build.svg)
+![license: ISC](https://raw.githubusercontent.com/git@gitlab.ptnl.moscow:constructor/platform/polymatica-widget/master/badges/license.svg)
+
+> Pre-Alpha

package/__internal__/io.d.ts

@@ -0,0 +1,55 @@
+import { Locale } from '../locale';
+import { Theme } from '../theme';
+import { Dataset, Options } from '../widget';
+export declare enum Input {
+    Change = "poly.input.change",
+    ChangeLang = "poly.input.changeLang",
+    ChangeTheme = "poly.input.changeTheme",
+    Highlight = "poly.input.highlight"
+}
+export declare enum Output {
+    Init = "poly.output.init",
+    Ready = "poly.output.ready",
+    Interact = "poly.output.interact"
+}
+export declare type InputDataset = Omit<Dataset, 'interact' | 'events'> & {
+    datasetId: number;
+};
+export interface InputSingleData {
+    readonly dataset: InputDataset;
+}
+export interface InputMultiData {
+    readonly datasets: {
+        [datasetKey: string]: InputDataset;
+    };
+}
+export declare type InputRepeatable<T extends InputSingleData | InputMultiData> = T extends InputSingleData ? {
+    readonly datasets: InputDataset[];
+} : {
+    readonly datasets: {
+        [datasetKey: string]: InputDataset | InputDataset[];
+    };
+};
+export declare type InputData = InputSingleData | InputMultiData | InputRepeatable<InputSingleData> | InputRepeatable<InputMultiData>;
+export interface InputParameter extends Record<Input, any> {
+    [Input.Change]: [InputData, Options];
+    [Input.ChangeLang]: Locale;
+    [Input.ChangeTheme]: Theme;
+    [Input.Highlight]: {
+        datasetId: number;
+        rowIndexArray: number[];
+    };
+}
+export interface OutputParameter extends Record<Output, any> {
+    [Output.Init]: void;
+    [Output.Ready]: void;
+    [Output.Interact]: {
+        datasetId: number;
+        dataIndex: number;
+    };
+}
+export interface OutputData {
+    token: string;
+    type: Output;
+    payload?: any;
+}

package/__internal__/io.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Output = exports.Input = void 0;
+var Input;
+(function (Input) {
+    Input["Change"] = "poly.input.change";
+    Input["ChangeLang"] = "poly.input.changeLang";
+    Input["ChangeTheme"] = "poly.input.changeTheme";
+    Input["Highlight"] = "poly.input.highlight";
+})(Input = exports.Input || (exports.Input = {}));
+var Output;
+(function (Output) {
+    Output["Init"] = "poly.output.init";
+    Output["Ready"] = "poly.output.ready";
+    Output["Interact"] = "poly.output.interact";
+})(Output = exports.Output || (exports.Output = {}));

package/__internal__/widget-options.d.ts

@@ -0,0 +1,32 @@
+import { Text } from '../locale';
+export declare enum WidgetOptionType {
+    Title = "title",
+    Label = "label",
+    Spacer = "spacer",
+    Text = "text",
+    Number = "number",
+    Integer = "integer",
+    Range = "range",
+    Interval = "interval",
+    Date = "date",
+    Time = "time",
+    DateTime = "datetime",
+    DateInterval = "date-interval",
+    Checkbox = "checkbox",
+    Radio = "radio",
+    RadioButtons = "radio-buttons",
+    Select = "select",
+    ColorPicker = "color-picker"
+}
+export interface WidgetOptionConfig {
+    type: WidgetOptionType;
+    key?: string;
+    label?: Text;
+    options?: {
+        label: Text;
+        value: string | number | boolean;
+    }[];
+    span?: number;
+}
+export declare function valueConversion(type: WidgetOptionType, source: any): any;
+export declare function getSpan(source?: number): number;

package/__internal__/widget-options.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpan = exports.valueConversion = exports.WidgetOptionType = void 0;
+const widget_config_1 = require("../widget-config");
+var WidgetOptionType;
+(function (WidgetOptionType) {
+    // Layout
+    WidgetOptionType["Title"] = "title";
+    WidgetOptionType["Label"] = "label";
+    WidgetOptionType["Spacer"] = "spacer";
+    // Controls
+    WidgetOptionType["Text"] = "text";
+    WidgetOptionType["Number"] = "number";
+    WidgetOptionType["Integer"] = "integer";
+    WidgetOptionType["Range"] = "range";
+    WidgetOptionType["Interval"] = "interval";
+    WidgetOptionType["Date"] = "date";
+    WidgetOptionType["Time"] = "time";
+    WidgetOptionType["DateTime"] = "datetime";
+    WidgetOptionType["DateInterval"] = "date-interval";
+    WidgetOptionType["Checkbox"] = "checkbox";
+    WidgetOptionType["Radio"] = "radio";
+    WidgetOptionType["RadioButtons"] = "radio-buttons";
+    WidgetOptionType["Select"] = "select";
+    WidgetOptionType["ColorPicker"] = "color-picker";
+})(WidgetOptionType = exports.WidgetOptionType || (exports.WidgetOptionType = {}));
+function valueConversion(type, source) {
+    switch (type) {
+        case WidgetOptionType.Text:
+        case WidgetOptionType.Title:
+            return source ? String(source) : '';
+        case WidgetOptionType.Number:
+        case WidgetOptionType.Range:
+            return source ? parseFloat(source) : 0;
+        case WidgetOptionType.Integer:
+            return source ? parseInt(source, 10) : 0;
+        case WidgetOptionType.Interval:
+            if (source)
+                return {
+                    from: parseFloat(source.from) || 0,
+                    to: parseFloat(source.to) || 0,
+                };
+            return { from: 0, to: 0 };
+        case WidgetOptionType.Date:
+        case WidgetOptionType.DateTime:
+            return parseDate(source);
+        case WidgetOptionType.Time:
+            return source || '00:00';
+        case WidgetOptionType.DateInterval:
+            if (source)
+                return {
+                    from: parseDate(source.from),
+                    to: parseDate(source.to),
+                };
+            return { from: new Date(), to: new Date() };
+        case WidgetOptionType.ColorPicker:
+        case WidgetOptionType.Radio:
+        case WidgetOptionType.Select:
+            return source;
+        case WidgetOptionType.Checkbox:
+            return Boolean(source);
+        default:
+            return '';
+    }
+}
+exports.valueConversion = valueConversion;
+function parseDate(source) {
+    const data = new Date(source);
+    return isNaN(data.valueOf()) ? new Date() : data;
+}
+function getSpan(source) {
+    const span = source | 0;
+    if (span > widget_config_1.STEP)
+        return widget_config_1.STEP;
+    if (span < 0)
+        return 0;
+    return span;
+}
+exports.getSpan = getSpan;

package/config.d.ts

@@ -0,0 +1,5 @@
+import { Text } from './locale';
+export interface Config {
+    label: Text;
+    icon: string;
+}

package/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dataset.d.ts

@@ -0,0 +1,16 @@
+export declare enum ColumnType {
+    String = "string",
+    Number = "number",
+    Date = "date",
+    Array = "array",
+    Object = "object",
+    Boolean = "boolean"
+}
+export interface DatasetRow {
+    [path: string]: any;
+}
+export interface Column {
+    type: ColumnType;
+    name: string;
+    path: string;
+}

package/dataset.js

@@ -0,0 +1,13 @@
+"use strict";
+// enums
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnType = void 0;
+var ColumnType;
+(function (ColumnType) {
+    ColumnType["String"] = "string";
+    ColumnType["Number"] = "number";
+    ColumnType["Date"] = "date";
+    ColumnType["Array"] = "array";
+    ColumnType["Object"] = "object";
+    ColumnType["Boolean"] = "boolean";
+})(ColumnType = exports.ColumnType || (exports.ColumnType = {}));

package/declare.d.ts

@@ -0,0 +1 @@
+export declare function Declare(): ClassDecorator;

package/declare.js

@@ -0,0 +1,122 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Declare = void 0;
+const logical_not_1 = require("logical-not");
+const io_1 = require("./__internal__/io");
+const datasetMap = new Map();
+function Declare() {
+    return (T) => {
+        const instance = new T();
+        const token = readFromUrl('token');
+        Object.assign(instance, {
+            options: {},
+            ready() {
+                output(token, io_1.Output.Ready);
+            },
+        });
+        let inited = false;
+        input(io_1.Input.Change, ([data, options]) => {
+            provideTo(instance, data, token);
+            set(instance, 'options', options);
+            if ((0, logical_not_1.not)(inited)) {
+                inited = true;
+                call(instance, 'init');
+            }
+            call(instance, 'onChange');
+        });
+        input(io_1.Input.ChangeLang, lang => {
+            set(instance, 'lang', lang);
+            if (inited)
+                call(instance, 'onLangChange');
+        });
+        input(io_1.Input.ChangeTheme, theme => {
+            set(instance, 'theme', theme);
+            if (inited)
+                call(instance, 'onThemeChange');
+        });
+        input(io_1.Input.Highlight, ({ datasetId, rowIndexArray }) => {
+            const dataset = datasetMap.get(datasetId);
+            dataset === null || dataset === void 0 ? void 0 : dataset.events.onHighlight(rowIndexArray);
+        });
+        output(token, io_1.Output.Init);
+        return T;
+    };
+}
+exports.Declare = Declare;
+function provideTo(widget, source, token) {
+    datasetMap.clear();
+    if ('dataset' in source) {
+        const { dataset } = source;
+        Object.assign(widget, {
+            dataset: transform(dataset, token),
+        });
+    }
+    else {
+        if (Array.isArray(source)) {
+            const { datasets } = source;
+            Object.assign(widget, {
+                datasets: datasets.map(dataset => transform(dataset, token)),
+            });
+        }
+        else {
+            const datasets = {};
+            Object.entries(source).forEach(([key, item]) => {
+                if (Array.isArray(item)) {
+                    datasets[key] = item.map(dataset => transform(dataset, token));
+                }
+                else {
+                    datasets[key] = transform(item, token);
+                }
+            });
+            Object.assign(widget, { datasets });
+        }
+    }
+}
+function transform(source, token) {
+    const { datasetId } = source, slice = __rest(source, ["datasetId"]);
+    const dataset = Object.assign(Object.assign({}, slice), { interact(dataIndex) {
+            output(token, io_1.Output.Interact, {
+                datasetId,
+                dataIndex,
+            });
+        }, events: {
+            onHighlight() { },
+        } });
+    datasetMap.set(datasetId, dataset);
+    return dataset;
+}
+function set(instance, key, value) {
+    instance[key] = value;
+}
+function call(instance, method) {
+    if (typeof instance[method] === 'function')
+        instance[method]();
+}
+function input(type, callback) {
+    window.addEventListener('message', ({ data }) => {
+        if (data.type === type)
+            callback(data.payload);
+    });
+}
+function output(token, type, payload) {
+    const message = { type, token, payload };
+    window.parent.postMessage(message, '*');
+}
+function readFromUrl(key) {
+    const startsWith = key + '=';
+    const source = window.location.search
+        .split(/[?&]/)
+        .find(item => item.startsWith(startsWith));
+    return source ? source.slice(startsWith.length) : '';
+}

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from './config';
+export * from './dataset';
+export * from './declare';
+export * from './locale';
+export * from './theme';
+export * from './widget-config';
+export * from './widget';

package/index.js

@@ -1 +1,19 @@
-
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);
+__exportStar(require("./dataset"), exports);
+__exportStar(require("./declare"), exports);
+__exportStar(require("./locale"), exports);
+__exportStar(require("./theme"), exports);
+__exportStar(require("./widget-config"), exports);
+__exportStar(require("./widget"), exports);

package/locale.d.ts

@@ -0,0 +1,2 @@
+export declare type Locale = 'ru' | 'en';
+export declare type Text = Record<Locale, string>;

package/locale.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,8 +1,11 @@
 {
     "name": "polymatica-widget",
-    "version": "0.7.0",
-    "description": "SDK для создания виджетов для модуля Dashboard платформы Polymatica",
+    "version": "2.0.2",
+    "description": "SDK для создания виджетов для платформы Polymatica",
     "keywords": [],
     "license": "ISC",
-    "main": "index.js"
-}
+    "main": "index.js",
+    "dependencies": {
+        "logical-not": "^1.0.9"
+    }
+}

package/theme.d.ts

@@ -0,0 +1,13 @@
+export interface Theme {
+    background: {
+        neutral: string;
+        tint: string[];
+        bright: string;
+    };
+    heatmap: string[][];
+    palette: string[];
+    text: {
+        primary: string;
+        secondary: string;
+    };
+}

package/theme.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/widget-config.d.ts

@@ -0,0 +1,129 @@
+import { Text } from './locale';
+import { Options } from './widget';
+import { WidgetOptionConfig } from './__internal__/widget-options';
+export declare enum DataQueryMethod {
+    Table = "table",
+    Aggregate = "aggregate"
+}
+export interface WidgetConfig {
+    data?: DataConfig | (DataConfig & WithKey)[];
+    options?: {
+        config: GetWidgetOptionsConfig;
+        default: Options;
+        validation?: OptionsValidation;
+    };
+}
+export interface DataConfig {
+    method: DataQueryMethod;
+    blocks: Block[];
+    label?: Text;
+    validation?: {
+        requiredSome?: string[];
+        requiredEvery?: string[];
+    };
+    iterable?: boolean;
+    heatmap?: boolean;
+    repeatable?: boolean;
+    min?: number;
+    max?: number;
+    pagination?: boolean;
+}
+export interface WithKey {
+    key: string;
+}
+export interface Block {
+    key: string;
+    label: Text;
+    icon?: string;
+    max?: number;
+}
+export declare const STEP = 24;
+export interface GetWidgetOptionsConfig {
+    (options: Options): WidgetOptionConfig[];
+}
+export declare function title(label: Text): WidgetOptionConfig;
+export declare function label(label: Text): WidgetOptionConfig;
+export declare function spacer(span: number): WidgetOptionConfig;
+export declare function text(params: {
+    key: string;
+    label: Text;
+    span?: number;
+}): WidgetOptionConfig;
+export declare function number(params: {
+    key: string;
+    label: Text;
+    span?: number;
+}): WidgetOptionConfig;
+export declare function integer(params: {
+    key: string;
+    label: Text;
+    span?: number;
+}): WidgetOptionConfig;
+export declare function range(params: {
+    key: string;
+    label: Text;
+    span?: number;
+}): WidgetOptionConfig;
+export declare function interval(params: {
+    key: string;
+    label: Text;
+    span?: number;
+}): WidgetOptionConfig;
+export declare function date(params: {
+    key: string;
+    label: Text;
+    span?: number;
+}): WidgetOptionConfig;
+export declare function time(params: {
+    key: string;
+    label: Text;
+    span?: number;
+}): WidgetOptionConfig;
+export declare function dateTime(params: {
+    key: string;
+    label: Text;
+    span?: number;
+}): WidgetOptionConfig;
+export declare function checkbox(params: {
+    key: string;
+    label: Text;
+    span?: number;
+}): WidgetOptionConfig;
+export declare function radio(params: {
+    key: string;
+    label: Text;
+    options: {
+        label: Text;
+        value: string;
+    }[];
+    span?: number;
+}): WidgetOptionConfig;
+export declare function radioButton(params: {
+    key: string;
+    label: Text;
+    options: {
+        label: Text;
+        value: string;
+    }[];
+    span?: number;
+}): WidgetOptionConfig;
+export declare function select(params: {
+    key: string;
+    label: Text;
+    options: {
+        label: Text;
+        value: string;
+    }[];
+    span?: number;
+}): WidgetOptionConfig;
+export declare function colorPicker(params: {
+    key: string;
+    label: Text;
+    span?: number;
+}): WidgetOptionConfig;
+export interface OptionsValidation {
+    [key: string]: OptionsValidator;
+}
+export interface OptionsValidator {
+    (value: any): Text | null;
+}

package/widget-config.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorPicker = exports.select = exports.radioButton = exports.radio = exports.checkbox = exports.dateTime = exports.time = exports.date = exports.interval = exports.range = exports.integer = exports.number = exports.text = exports.spacer = exports.label = exports.title = exports.STEP = exports.DataQueryMethod = void 0;
+const widget_options_1 = require("./__internal__/widget-options");
+// enums
+var DataQueryMethod;
+(function (DataQueryMethod) {
+    DataQueryMethod["Table"] = "table";
+    DataQueryMethod["Aggregate"] = "aggregate";
+})(DataQueryMethod = exports.DataQueryMethod || (exports.DataQueryMethod = {}));
+// widget options
+exports.STEP = 24;
+// layout
+function title(label) {
+    return { type: widget_options_1.WidgetOptionType.Title, label };
+}
+exports.title = title;
+function label(label) {
+    return { type: widget_options_1.WidgetOptionType.Label, label };
+}
+exports.label = label;
+function spacer(span) {
+    return { type: widget_options_1.WidgetOptionType.Spacer, span };
+}
+exports.spacer = spacer;
+// controls
+function text(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.Text }, params);
+}
+exports.text = text;
+function number(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.Number }, params);
+}
+exports.number = number;
+function integer(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.Integer }, params);
+}
+exports.integer = integer;
+function range(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.Range }, params);
+}
+exports.range = range;
+function interval(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.Interval }, params);
+}
+exports.interval = interval;
+function date(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.Date }, params);
+}
+exports.date = date;
+function time(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.Time }, params);
+}
+exports.time = time;
+function dateTime(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.DateTime }, params);
+}
+exports.dateTime = dateTime;
+function checkbox(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.Checkbox }, params);
+}
+exports.checkbox = checkbox;
+function radio(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.Radio }, params);
+}
+exports.radio = radio;
+function radioButton(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.RadioButtons }, params);
+}
+exports.radioButton = radioButton;
+function select(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.Select }, params);
+}
+exports.select = select;
+function colorPicker(params) {
+    return Object.assign({ type: widget_options_1.WidgetOptionType.ColorPicker }, params);
+}
+exports.colorPicker = colorPicker;

package/widget.d.ts

@@ -0,0 +1,47 @@
+import { Column, DatasetRow } from './dataset';
+import { Locale } from './locale';
+import { Theme } from './theme';
+export declare abstract class Widget {
+    readonly options: Options;
+    readonly theme: Theme;
+    readonly lang: Locale;
+    ready(): void;
+    init(): void;
+    abstract onChange(): void;
+    onThemeChange(): void;
+    onLangChange(): void;
+}
+export interface SingleData {
+    readonly dataset: Dataset;
+}
+export interface MultiData {
+    readonly datasets: {
+        [datasetKey: string]: Dataset;
+    };
+}
+export declare type Repeatable<T extends SingleData | MultiData> = T extends SingleData ? {
+    readonly datasets: Dataset[];
+} : {
+    readonly datasets: {
+        [datasetKey: string]: Dataset | Dataset[];
+    };
+};
+export interface Dataset {
+    columns: Column[];
+    columnsByBlock: {
+        [blockKey: string]: Column[];
+    };
+    rows: DatasetRow[];
+    heatmap: HeatmapItem[];
+    interact(rowIndex: number): void;
+    events: {
+        onHighlight: (rowIndexArray: number[]) => void;
+    };
+}
+export interface HeatmapItem {
+    column: Column;
+    getColor(value: number): string;
+}
+export interface Options {
+    [key: string]: any;
+}

package/widget.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Widget = void 0;
+class Widget {
+    ready() { }
+    init() { }
+    onThemeChange() { }
+    onLangChange() { }
+}
+exports.Widget = Widget;