polymatica-widget 0.7.1 → 2.0.3

package/{src/widget.ts → widget.d.ts}

@@ -1,57 +1,47 @@
 import { Column, DatasetRow } from './dataset';
 import { Locale } from './locale';
 import { Theme } from './theme';
-
-export abstract class Widget {
-    readonly options!: Options;
-    readonly theme!: Theme;
-    readonly lang!: Locale;
-
-    ready(): void {}
-
-    init(): void {}
-
+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 {}
+    onThemeChange(): void;
+    onLangChange(): void;
 }
-
 export interface SingleData {
     readonly dataset: Dataset;
 }
-
 export interface MultiData {
-    readonly datasets: { [datasetKey: string]: Dataset };
+    readonly datasets: {
+        [datasetKey: string]: Dataset;
+    };
 }
-
-export type Repeatable<T extends SingleData | MultiData> = T extends SingleData
-    ? { readonly datasets: Dataset[] }
-    : {
-          readonly datasets: {
-              [datasetKey: string]: Dataset | 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[] };
+    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;

package/.prettierrc.json

@@ -1,6 +0,0 @@
-{
-    "arrowParens": "avoid",
-    "singleQuote": true,
-    "tabWidth": 4,
-    "trailingComma": "all"
-}

package/scripts/build.js

@@ -1,23 +0,0 @@
-const { writeFileSync: writeFile } = require('fs');
-const { join, resolve } = require('path');
-const { cp, exec, exit, rm, test } = require('shelljs');
-
-if (process.cwd() !== join(__dirname, '..')) exit(1);
-
-if (test('-d', 'package')) rm('-rf', 'package');
-
-exec('tsc');
-
-cp('LICENSE', 'README.md', 'package');
-
-createPackageJSON: {
-    const source = require('../package.json');
-
-    delete source.scripts;
-    delete source.devDependencies;
-
-    const path = resolve('package/package.json');
-    const file = JSON.stringify(source, null, '  ');
-
-    writeFile(path, file);
-}

package/src/__internal__/io.ts

@@ -1,68 +0,0 @@
-import { Locale } from '../locale';
-import { Theme } from '../theme';
-import { Dataset, MultiData, Repeatable, SingleData, Options } from '../widget';
-
-export enum Input {
-    Change = 'poly.input.change',
-    ChangeLang = 'poly.input.changeLang',
-    ChangeTheme = 'poly.input.changeTheme',
-    Highlight = 'poly.input.highlight',
-}
-
-export enum Output {
-    Init = 'poly.output.init',
-    Ready = 'poly.output.ready',
-    Interact = 'poly.output.interact',
-}
-
-export type InputDataset = Omit<Dataset, 'interact' | 'events'> & {
-    datasetId: number;
-};
-
-export interface InputSingleData {
-    readonly dataset: InputDataset;
-}
-
-export interface InputMultiData {
-    readonly datasets: { [datasetKey: string]: InputDataset };
-}
-
-export type InputRepeatable<T extends InputSingleData | InputMultiData> =
-    T extends InputSingleData
-        ? { readonly datasets: InputDataset[] }
-        : {
-              readonly datasets: {
-                  [datasetKey: string]: InputDataset | InputDataset[];
-              };
-          };
-
-export 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/src/__internal__/widget-config.ts

@@ -1,72 +0,0 @@
-import { Text } from '../locale';
-import { ColumnType } from '../dataset';
-import { AggregateFunction } from '../widget-config';
-
-// enums
-
-export enum BlockType {
-    Data = 'data',
-    Filter = 'filter',
-    Sort = 'sort',
-    Heatmap = 'heatmap',
-    Drilldown = 'drilldown',
-    RowsLimit = 'rows-limit',
-}
-
-// interfaces
-
-export interface Block {
-    type: BlockType;
-    key: string;
-    label: Text;
-    icon?: string;
-    aggregateFunction?: AggregateFunction;
-    columnTypes?: ColumnType[];
-    max?: number;
-}
-
-export function decodeDrilldownData(
-    source: string,
-    additionalFilterSources: string[],
-): string {
-    const keyParts: string[] = [length(source.length), source];
-
-    additionalFilterSources.forEach(item =>
-        keyParts.push(length(item.length), item),
-    );
-
-    return keyParts.join('');
-
-    function length(value: number): string {
-        if (value > 0xff) throw new RangeError();
-
-        return value > 0xf
-            ? `0x${value.toString(16)}`
-            : `0x0${value.toString(16)}`;
-    }
-}
-
-export function encodeDrilldownData(key: string): {
-    source: string;
-    additionalFilterSources: string[];
-} {
-    const parts: string[] = [];
-
-    parse();
-
-    const [source, ...additionalFilterSources] = parts;
-
-    return {
-        source,
-        additionalFilterSources,
-    };
-
-    function parse(offset = 0): void {
-        const start = offset + 4;
-        const end = start + parseInt(key.slice(offset, start));
-
-        parts.push(key.slice(start, end));
-
-        if (end < key.length) parse(end);
-    }
-}

package/src/__internal__/widget-options.ts

@@ -1,83 +0,0 @@
-import { Text } from '../locale';
-import { STEP } from '../widget-config';
-
-export enum WidgetOptionType {
-    Text = 'text',
-    Number = 'number',
-    Integer = 'integer',
-    Range = 'range',
-    Interval = 'interval',
-    Date = 'date',
-    Time = 'time',
-    DateTime = 'datetime',
-    DateInterval = 'dateinterval',
-    Checkbox = 'checkbox',
-    Radio = 'radio',
-    Select = 'select',
-    ColorPicker = 'color-picker',
-    Title = 'title',
-}
-
-export interface WidgetOptionConfig {
-    type: WidgetOptionType;
-    key: string;
-    label: Text;
-    defaultValue?: any;
-    options?: { label: Text; value: string | number | boolean }[];
-    span?: number;
-}
-
-export function valueConversion(type: WidgetOptionType, source: any): any {
-    switch (type) {
-        case WidgetOptionType.Text:
-            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 '';
-    }
-}
-
-function parseDate(source: any): Date {
-    const data = new Date(source);
-
-    return isNaN(data.valueOf()) ? new Date() : data;
-}
-
-export function getSpan(source?: number): number {
-    const span = source! | 0;
-
-    if (span > STEP) return STEP;
-    if (span < 0) return 0;
-
-    return span;
-}

package/src/dataset.ts

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

package/src/declare.ts

@@ -1,186 +0,0 @@
-import { not } from 'logical-not';
-
-import { Dataset, SingleData, Widget } from './widget';
-
-import {
-    Input,
-    InputData,
-    InputDataset,
-    InputParameter,
-    InputRepeatable,
-    InputSingleData,
-    Output,
-    OutputData,
-    OutputParameter,
-} from './__internal__/io';
-
-const datasetMap = new Map<number, Dataset>();
-
-export function Declare(): ClassDecorator {
-    return (T: any) => {
-        const instance: Widget = new T();
-        const token = readFromUrl('token');
-
-        Object.assign(instance, {
-            options: {},
-
-            ready(): void {
-                output<Output.Ready>(token, Output.Ready);
-            },
-        } as Partial<Widget>);
-
-        let inited = false;
-
-        input<InputParameter[Input.Change]>(Input.Change, ([data, options]) => {
-            provideTo(instance, data, token);
-
-            set(instance, 'options', options);
-
-            if (not(inited)) {
-                inited = true;
-
-                call(instance, 'init');
-            }
-
-            call(instance, 'onChange');
-        });
-
-        input<InputParameter[Input.ChangeLang]>(Input.ChangeLang, lang => {
-            set(instance, 'lang', lang);
-
-            if (inited) call(instance, 'onLangChange');
-        });
-
-        input<InputParameter[Input.ChangeTheme]>(Input.ChangeTheme, theme => {
-            set(instance, 'theme', theme);
-
-            if (inited) call(instance, 'onThemeChange');
-        });
-
-        input<InputParameter[Input.Highlight]>(
-            Input.Highlight,
-            ({ datasetId, rowIndexArray }) => {
-                const dataset = datasetMap.get(datasetId);
-
-                dataset?.events.onHighlight(rowIndexArray);
-            },
-        );
-
-        output<Output.Init>(token, Output.Init);
-
-        return T;
-    };
-}
-
-function provideTo(widget: any, source: InputData, token: string): void {
-    datasetMap.clear();
-
-    if ('dataset' in source) {
-        const { dataset } = source as InputSingleData;
-
-        Object.assign(widget, {
-            dataset: transform(dataset, token),
-        });
-    } else {
-        if (Array.isArray(source)) {
-            const { datasets } = source as InputRepeatable<InputSingleData>;
-
-            Object.assign(widget, {
-                datasets: datasets.map(dataset => transform(dataset, token)),
-            });
-        } else {
-            const datasets: Record<string, Dataset | Dataset[]> = {};
-
-            Object.entries(source).forEach(
-                ([key, item]: [string, InputDataset | InputDataset[]]) => {
-                    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: InputDataset, token: string): Dataset {
-    const { datasetId, ...slice } = source;
-
-    const dataset: Dataset = {
-        ...slice,
-
-        interact(dataIndex: number): void {
-            output<Output.Interact>(token, Output.Interact, {
-                datasetId,
-                dataIndex,
-            });
-        },
-
-        events: {
-            onHighlight() {},
-        },
-    };
-
-    datasetMap.set(datasetId, dataset);
-
-    return dataset;
-}
-
-function set<Key extends keyof Widget>(
-    instance: Widget,
-    key: Key,
-    value: Widget[Key],
-): void {
-    (instance as Writeable<Widget, Key>)[key] = value;
-}
-
-type Writeable<T extends { [x: string]: any }, K extends string> = {
-    -readonly [P in K]: T[P];
-};
-
-function call(instance: Widget, method: keyof Widget): void {
-    if (typeof instance[method] === 'function')
-        (instance[method] as Function)();
-}
-
-interface TransportEvent<TPayload> {
-    type: Input | Output;
-    payload: TPayload;
-    token?: string;
-}
-
-function input<TPayload = void>(
-    type: Input,
-    callback: (payload: TPayload) => void,
-): void {
-    window.addEventListener(
-        'message',
-        ({ data }: MessageEvent<TransportEvent<TPayload>>) => {
-            if (data.type === type) callback(data.payload);
-        },
-    );
-}
-
-function output<T extends Output>(
-    token: string,
-    type: T,
-    payload?: OutputParameter[T],
-): void {
-    const message: OutputData = { type, token, payload };
-
-    window.parent.postMessage(message, '*');
-}
-
-function readFromUrl(key: string): string {
-    const startsWith = key + '=';
-    const source = window.location.search
-        .split(/[?&]/)
-        .find(item => item.startsWith(startsWith));
-
-    return source ? source.slice(startsWith.length) : '';
-}

package/src/locale.ts

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