@windycom/plugin-devtools 1.0.1

package/README.md

@@ -0,0 +1,3 @@
+# Windy Plugins Developer tools
+
+Check out https://docs.windy-plugins.com for more information.

package/index.mjs

@@ -0,0 +1,298 @@
+// Transferred via https://transform.tools/typescript-to-javascript
+import fs from 'fs';
+import assert from 'assert';
+import MagicString from 'magic-string';
+import { walk } from 'estree-walker';
+
+const testLoadedPlugin = config => {
+    const { name, version, title, desktopUI, mobileUI, routerPath, icon } = config;
+
+    assert(
+        typeof name === 'string' && /^windy-plugin-([a-z0-9-]+)$/.test(name),
+        'Plugin name MUST be prefixed with windy-plugin- string and can contain only lowercase letters, numbers and dashes',
+    );
+
+    assert(
+        typeof version === 'string' && version.match(/^\d+\.\d+\.\d+$/),
+        'Plugin version is not defined or is not in semversion format (example: 1.3.7)',
+    );
+
+    assert(
+        typeof icon === 'string' && /^.$/u.test(icon),
+        'Plugin icon MUSt be just single emoji character',
+    );
+
+    assert(
+        !routerPath ||
+            (typeof routerPath === 'string' &&
+                routerPath.length > 4 &&
+                /^\/[a-z0-9-/:?]+$/.test(routerPath)),
+        'Router path MUST be longer than 4 characters and can contain only lowercase letters, numbers and dashes (example hello-world). It must have leading slash "/".',
+    );
+
+    assert(
+        typeof title === 'string' && title.length > 7 && title.length < 50,
+        'Plugin title is not defined or is too short or too long',
+    );
+
+    assert(
+        typeof desktopUI === 'string' && desktopUI.match(/^(rhpane|embedded)$/),
+        'Plugin desktopUI is not defined or is not one of allowed values',
+    );
+
+    assert(
+        typeof mobileUI === 'string' && mobileUI.match(/^(fullscreen|small|embedded)$/),
+        'Plugin mobileUI is not defined or is not one of allowed values',
+    );
+};
+
+/**
+ * Replaces @windy/, @plugins/ virtual imports in the given AST with the appropriate code modifications.
+ *
+ * @param ast - The Abstract Syntax Tree (AST) representing the code.
+ * @param msCode - The MagicString object representing the code with source maps.
+ */
+const replaceVirualImports = (ast, msCode) => {
+    walk(ast, {
+        enter(node) {
+            if (node.type === 'ImportDeclaration') {
+                const source = node.source.value?.toString() || '';
+                const { start, end, specifiers } = node;
+
+                const removeEmptyImpoert = () => {
+                    const originalString = msCode.slice(start, end);
+                    msCode.overwrite(
+                        start,
+                        end,
+                        `// transformCode (empty import): ${originalString}`,
+                    );
+                };
+
+                if (source.startsWith('@windy/')) {
+                    if (!specifiers || !specifiers.length) {
+                        // Empty useless import line like: import '@windy/whatever';
+                        removeEmptyImpoert();
+                    } else {
+                        const originalString = msCode.slice(start, end);
+                        const windyModuleId = source.replace('@windy/', '');
+                        let newCode = `// transformCode: ${originalString}\n`;
+
+                        const multipleSpecifiers = [];
+                        for (const specifier of specifiers) {
+                            if (specifier.type === 'ImportSpecifier') {
+                                // named imports
+                                if (specifier.imported.name === specifier.local.name) {
+                                    multipleSpecifiers.push(specifier.local.name);
+                                } else {
+                                    multipleSpecifiers.push(
+                                        `${specifier.imported.name}: ${specifier.local.name}`,
+                                    );
+                                }
+                            } else {
+                                // default import, or import to one variable
+                                newCode += `const ${specifier.local.name} = W.${windyModuleId};\n`;
+                            }
+                        }
+                        if (multipleSpecifiers.length) {
+                            newCode += `const { ${multipleSpecifiers.join(
+                                ', ',
+                            )} } = W.${windyModuleId};\n`;
+                        }
+                        msCode.overwrite(start, end, newCode);
+                    }
+                }
+            }
+        },
+    });
+};
+
+/**
+ * Replaces the export statements in the given AST with a modified export statement.
+ * If no export statements are found, a new export statement is added.
+ *
+ * @param ast - The Abstract Syntax Tree (AST) of the code.
+ * @param msCode - The MagicString instance representing the code.
+ * @param addedLiterars - An array of additional literals to be exported.
+ */
+const replaceExports = (ast, msCode, addedLiterars) => {
+    let exportWasReplaced = false;
+    walk(ast, {
+        enter(node) {
+            if (node.type === 'ExportNamedDeclaration') {
+                const { start, end, specifiers } = node;
+                const specifierLiterals = specifiers?.map(s => {
+                    if (s.local.name === s.exported.name) {
+                        return s.local.name;
+                    } else {
+                        return `${s.local.name} as ${s.exported.name}`;
+                    }
+                });
+                const newExports = [...addedLiterars, ...specifierLiterals];
+                const newCode = `\n// transformCode: Export statement was modified\nexport { ${newExports.join(
+                    ', ',
+                )} };\n`;
+                msCode.append(newCode);
+                msCode.remove(start, end);
+                exportWasReplaced = true;
+            }
+        },
+    });
+
+    if (!exportWasReplaced) {
+        const newCode = `\n// transformCode: Export statement was added\nexport { ${addedLiterars.join(
+            ', ',
+        )} };\n`;
+        msCode.append(newCode);
+    }
+};
+
+/**
+ * Transforms the code based on the provided parameters.
+ */
+const transformCode = async (code, sourcemaps, pluginContext, path, output) => {
+    const ast = pluginContext.parse(code);
+    const msCode = new MagicString(code);
+
+    replaceVirualImports(ast, msCode);
+
+    const configPath = `${path}/pluginConfig.ts`;
+    let screenshot;
+
+    // Copy screenshot.jpg/png/webp/jpeg to the output directory
+    try {
+        for (const type of ['jpg', 'png', 'webp', 'jpeg']) {
+            const screenshotPath = `${path}/screenshot.${type}`;
+            if (fs.existsSync(screenshotPath)) {
+                fs.copyFileSync(screenshotPath, `${output}/screenshot.${type}`);
+                screenshot = `screenshot.${type}`;
+                break;
+            }
+        }
+    } catch (e) {
+        console.error(`Error while copying screenshot`, e);
+    }
+
+    try {
+        // This part of code reads the pluginConfig.ts file and
+        // make the most stupid regex/eval extracting of the object
+        // properties. It is not perfect, but it works.
+        const configFile = fs.readFileSync(configPath, 'utf8');
+        const getObjectParser = /^[^{]+(?<body>{(?:[^}]*name:[^}]+)+})[^}]+$/gm; // https://regex101.com/r/0VX3vT/2
+        const dirtyBody = getObjectParser.exec(configFile)?.groups?.body;
+        const pluginConfig = eval(`(${dirtyBody})`);
+
+        testLoadedPlugin(pluginConfig);
+
+        pluginConfig.built = Date.now();
+        pluginConfig.builtReadable = new Date().toISOString();
+        pluginConfig.screenshot = screenshot;
+
+        const formattedConfig = JSON.stringify(pluginConfig, undefined, 2);
+
+        fs.writeFileSync(`${output}/plugin.json`, formattedConfig);
+
+        msCode.prepend(`const __pluginConfig =  ${formattedConfig};\n\n`);
+    } catch (e) {
+        console.error(`Error while opening and parsing ${configPath}`, e);
+        process.exit(1);
+    }
+
+    replaceExports(ast, msCode, ['__pluginConfig']);
+
+    return {
+        code: msCode.toString(),
+        map: sourcemaps ? msCode.generateMap({ hires: true }) : undefined,
+    };
+};
+
+/**
+ * Creates a Rollup plugin that transforms code to ESM format with our enhancements
+ * @returns The Rollup plugin.
+ */
+export function transformCodeToESMPlugin() {
+    let shouldGenerateSourcemaps = false;
+    let outputDirectory = null;
+    return {
+        name: 'transform-to-esm-plugin',
+        options(options) {
+            const outputOptions = Array.isArray(options.output)
+                ? options.output[0]
+                : options.output ?? {};
+
+            shouldGenerateSourcemaps = Boolean(outputOptions.sourcemap);
+            outputDirectory = outputOptions.file.replace(/\/[^/]+$/, '');
+
+            return undefined;
+        },
+        renderChunk(code, chunk) {
+            const { facadeModuleId } = chunk;
+            const pathOfTheFile = facadeModuleId.replace(/\/[^/]*$/, '');
+
+            if (!fs.existsSync(outputDirectory)) {
+                fs.mkdirSync(outputDirectory, { recursive: true });
+            }
+
+            return transformCode(
+                code,
+                shouldGenerateSourcemaps,
+                this,
+                pathOfTheFile,
+                outputDirectory,
+            );
+        },
+    };
+}
+
+export const certificatePEM = `
+-----BEGIN CERTIFICATE-----
+MIIDWTCCAkGgAwIBAgIJAJsJO7x13pwAMA0GCSqGSIb3DQEBCwUAMEMxCzAJBgNV
+BAYTAkNaMRAwDgYDVQQIDAdDemVjaGlhMQ4wDAYDVQQKDAVXaW5keTESMBAGA1UE
+AwwJbG9jYWxob3N0MB4XDTE4MTAyNTEyMzc1NloXDTI4MTAyMjEyMzc1NlowQzEL
+MAkGA1UEBhMCQ1oxEDAOBgNVBAgMB0N6ZWNoaWExDjAMBgNVBAoMBVdpbmR5MRIw
+EAYDVQQDDAlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
+AQDKLfu9uX9A97rUE0kTGa7COeShMz4SJVQI+2Z7dV+6MC42rNpvbPjyWMKMjMTi
+p6ARYrDtG6ARNETV+RIYBOIAEU5InKGJNdpOSlTxFq87XDTwdYtG9XLYhQZTOFSk
+DjgwZkFfcXDbnhwzyu2tF+nPP1kt7k0qt0AwNn/QI3RvRlWC9gpX644xHyJPp6H7
+6M4gxYvNw9Eh+UrbAbp27+tnQEd+qQi9adK3qi2C0GL787HEhIA18A4EJY7PIrIN
+NjD4r9IiFF78pZFXEUszE2aE4GVe8v12VmhRPntPUgKLskFZAuAnKOxan8zar7b5
+bIDq9M0l/+JqN7x+nB9Cx9kLAgMBAAGjUDBOMB0GA1UdDgQWBBSCb0qLtMQ8cub9
+Go4xvwJfsWh0azAfBgNVHSMEGDAWgBSCb0qLtMQ8cub9Go4xvwJfsWh0azAMBgNV
+HRMEBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQAJTqnecj58DrQXvWFwyewbWH2Q
+hkv6vggR6+yM3J63bm4MBYjHs2Ut21TFlcN6ItwzIPP0prVgGrbrx7L6vJNDaDVO
+ycaSicw++fuIIFZzmvn7ALQbRz4KtmmUqT/m6WoGyhWolDjweaPZDcmbErw8XZrk
+rNWi3It/WA5COBxVdPzgv6vyB6FmZKNgqgaRO1NUXcNenGGR+V3CFwhmCsXsiM0G
+L2eqlverl/YyiFUECWXsUmjpVnt86px7NXMsdBOLHJyJMAB2iLgR7gy/StV1zxSX
+l48WMLKAXRnbcrsrAUXgfkJbaviTyvCgwFmx99yc4oP9onbEbNQJdp4gTrat
+-----END CERTIFICATE-----
+`;
+
+export const keyPEM = `
+-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDKLfu9uX9A97rU
+E0kTGa7COeShMz4SJVQI+2Z7dV+6MC42rNpvbPjyWMKMjMTip6ARYrDtG6ARNETV
++RIYBOIAEU5InKGJNdpOSlTxFq87XDTwdYtG9XLYhQZTOFSkDjgwZkFfcXDbnhwz
+yu2tF+nPP1kt7k0qt0AwNn/QI3RvRlWC9gpX644xHyJPp6H76M4gxYvNw9Eh+Urb
+Abp27+tnQEd+qQi9adK3qi2C0GL787HEhIA18A4EJY7PIrINNjD4r9IiFF78pZFX
+EUszE2aE4GVe8v12VmhRPntPUgKLskFZAuAnKOxan8zar7b5bIDq9M0l/+JqN7x+
+nB9Cx9kLAgMBAAECggEBAKIE/ZNJ3t+KZs7i8ZF76F8/k6dW8CwMe+6CwNq48dC8
+IZyxIo9erZVQaf/GI1VbbVvhUdWBaOHAmFU8tzJGX3IcbDamRpE1dc99o9pcCmsw
+dkAogkeIFNPMrofsQXAC8SZgG41H1GA6sXET8yneWwE5S9cR/Ab6OVcppX1/nCQ6
+tSLCTi5Uxqq1T2qdVPwGsm0GtE3XvLkfhoQBjt46T+pOVECshkFIIcpRdLaK/Q7+
+PUfQDEgmsqV1qViLMm01nFJTHlZvL3rVS64HojPXXB6gtuCAN7K9RKWUlwhlklPb
+M+ydISklWwbvLbIqALKsGqeLk7tf9FHd7WFJHUnTkkkCgYEA6wnYfTAGuAoAHMoa
+7mVrSqxytlKcudnkr0LaTvBQ0o0IRLPi21kZIZzjT6jt5SSZmwZzvwr0TFCCuvHW
+wfJnSdYCy/oB/g4D2oViGKus4sbzlS1MOvPNzlUzyp1h2ugdgBlyCzopn9MgZQVg
+uOyzY34ChIdhyDE8yWmOI9cQSqUCgYEA3DXwViUToYuvgjq3+UfZDFMjSYJd3LOO
+NjzhRxNxWZJxEXbO799m/zDSmWUJU/wPTJcIyM9eYcRxCoj2JyyLy0dGmq/2n8Nv
+hQj0NpeEdpm6dn0kJMnNgSeqrjbMIlkgYkafp+24lbUnyiJV8akV/twYylBOfCuQ
+jKKov0pGNe8CgYEA47RSLFZO7BWkLkAO/076NwoCyGgYtmVGjBT0cu2XH6TKkeTE
+r0UOd+YKwq4ia5Cdz/bcRAVU0GpffMW3DYbOUlYnt32qWHszeI0okEYh5EJi0e9k
+nuh8Rp1845q9ptqhWe1M81uR3+kmxTgEkKOg147I2aRfMxegkHDW6Bn/CpECgYB2
+3C5jcRPNiIYtNuCCjwNaoa1USie7rrc+E1JNePMfs+mP0Z8U3nLLn2CtJ1oHmO/x
+GTzGlxeMkemqFA85SdQS3t//MqddyLFzD0gyB0qacZOxzQ4rRTnFUtHPwwggKhdO
+tGwMykVtmSBm/G2DSQ70R3yiBwK2BxW4szt+NOr8xQKBgFZKzJJJCI7tIx4Q4W6u
+eXBYiWI6UlNpl7NRaaomk1rfIF6mZwN4jdNMSCaYxMRS6AeMBLF7a3t1SaZ+rOAM
+h3aspktieVxk6EW6XE5niS8FphEdWc2ttqPYTEH/xlnyk5huBtgUbIWfjdK2sPcy
+5MnCHcPPkW3bLxyZSC9y84aP
+-----END PRIVATE KEY-----
+`;

package/package.json

@@ -0,0 +1,9 @@
+{
+    "name": "@windycom/plugin-devtools",
+    "version": "1.0.1",
+    "description": "Developer tools and TS declarations for developers of Windy Plugins.",
+    "main": "index.mjs",
+    "module": "index.mjs",
+    "author": "Windyty, S.E.",
+    "license": "ISC"
+}

package/publishExamples.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+source .secret-api-key.sh
+
+NAME=example
+SHA=$(git rev-parse --short HEAD)
+OWNER=windycom
+
+DIR=dist/example05
+
+cd ./$DIR
+echo "Creating plugin archive..."
+echo "{\"repositoryName\": \"https://github.com/windycom/windy-plugin-template\", \"commitSha\": \"${SHA}\", \"repositoryOwner\": \"${OWNER}\"}" > ./plugin-info.json
+jq -s '.[0] * .[1]' ./plugin.json ./plugin-info.json > ./plugin2.json
+rm ./plugin.json && mv ./plugin2.json ./plugin.json
+tar cf ./plugin.tar --exclude='./plugin.tar' .
+echo "Publishing plugin..."
+curl -s --fail-with-body -XPOST 'https://api.windy.com/api/windy-plugins/v1.0/upload' -H "x-windy-api-key: ${WINDY_API_KEY}" -F "plugin_archive=@./plugin.tar"
+rm ./plugin.tar

package/types/AromeProduct.d.ts

@@ -0,0 +1,5 @@
+import { Product } from '@windy/Product';
+import type { ProductInitParams } from '@windy/Product';
+export declare class AromeProduct extends Product {
+    constructor(params: Partial<ProductInitParams>);
+}

package/types/Bar.d.ts

@@ -0,0 +1,114 @@
+/**
+ * @class Bar
+ * Horizontal ProgressBar Class binded to stores's `timestamp`
+ * @example
+ *
+ *    new Bar({
+ *        progressLine: _.$(...)    // el to catch mouseevents
+ *    })
+ */
+import { Drag } from '@windy/Drag';
+import { GhostBox } from '@windy/GhostBox';
+import type { Calendar } from '@windy/Calendar';
+import type { Timestamp } from '@windy/types';
+export type BarInitParams = {
+    progressBar: HTMLDivElement;
+    offset?: number;
+    borderOffset?: number;
+    jumpingGhost?: boolean;
+    bcastLimit?: number;
+    jumpingWidth?: number;
+    resizableEl?: HTMLElement;
+};
+export declare class Bar {
+    protected drag: Drag;
+    protected ghostBox?: GhostBox;
+    /**
+     * EL of wrapping element,
+     */
+    private progressBar;
+    /**
+     * A progress line to be used in GhostBox. We need to make a copy here for mobile where
+     * the GhostBox is not present.
+     */
+    private progressLine;
+    /**
+     * Offset from left side of begginging of pb
+     */
+    private offset;
+    /**
+     * offset of pb from border of a screen
+     */
+    private borderOffset;
+    /**
+     * How often bcast dragging
+     */
+    private bcastLimit;
+    /**
+     * Width of main box fo ghost jumping
+     */
+    protected jumpingWidth: number;
+    private maxWidth;
+    private pxRatio;
+    private timecode;
+    private nowMark?;
+    private played?;
+    private ghostTxt?;
+    private throttledBcast;
+    protected progressWidth: number;
+    protected calendar: Calendar | null;
+    protected left: number;
+    protected calendarHours: number;
+    protected timestamp: Timestamp;
+    protected text: HTMLDivElement;
+    protected resizableEl: HTMLElement;
+    /**
+     * Should ghost box jump over timebox?
+     */
+    jumpingGhost: boolean;
+    constructor(params: BarInitParams);
+    /**
+     * creates text in the timeBox on a basis of
+     * relative position on a progressBar
+     */
+    protected createText(_el: HTMLDivElement): string;
+    protected pos2ts(pos: number): number;
+    protected createGhostText(_left: number): string;
+    protected setTimestamp(ts: number): void;
+    /**
+     * Time box change its position
+     */
+    protected update(newPos: number): number;
+    /**
+     * Call recalculate && setIndex
+     */
+    protected onresize(): void;
+    /**
+     * Click on progress bar
+     */
+    protected click(event: MouseEvent): void;
+    /**
+     * Sets timestamp
+     * noAnimation ... do not do CSS animation
+     */
+    protected set(timestamp: Timestamp): void;
+    protected onbcast(): void;
+    protected ondragstart(_startXY: [number, number]): void;
+    protected ondragend(_e: MouseEvent | TouchEvent): void;
+    /**
+     * Main timebox
+     */
+    private ondrag;
+    /**
+     * Updates timestamp and broadcasts it out
+     */
+    private bcast;
+    private addAnimation;
+    private removeAnimation;
+    /**
+     * Position based on ts
+     */
+    private ts2pos;
+    private updateBarFreeRange;
+    private updateGhost;
+}

package/types/BindedBar.d.ts

@@ -0,0 +1,51 @@
+import { Bar } from '@windy/Bar';
+import type { BarInitParams } from '@windy/Bar';
+import type { Calendar } from '@windy/Calendar';
+import type { PickDataSpecificationPropsByType } from '@windy/dataSpecifications.d';
+import type { TimeFormatFunction } from '@windy/format.d';
+import type { Timestamp } from '@windy/types.d';
+export type BindedBarInitParams = {
+    UIident: string;
+    bindTimestamp: keyof PickDataSpecificationPropsByType<Timestamp>;
+    bindCalendar: keyof PickDataSpecificationPropsByType<Calendar, false>;
+    bindAnimation: keyof PickDataSpecificationPropsByType<boolean>;
+} & BarInitParams;
+export declare class BindedBar extends Bar {
+    /**
+     * To prevent cycling
+     */
+    protected UIident: string;
+    /**
+     * Value to be binded as timetamp
+     */
+    protected bindTimestamp: keyof PickDataSpecificationPropsByType<Timestamp>;
+    /**
+     * Value to be binded as calendar
+     */
+    private bindCalendar;
+    /**
+     * Value binded with animation true/false
+     */
+    private bindAnimation;
+    protected displayHour: TimeFormatFunction;
+    protected zuluMode: boolean;
+    protected numberOfHours: number;
+    constructor(params: BindedBarInitParams);
+    unmount(): void;
+    protected onbcast(): void;
+    protected stopAnim(): void;
+    protected ondragstart(_startXY: [number, number]): void;
+    /**
+     * Click on progress bar -> stop animation
+     * @param event
+     */
+    protected click(event: MouseEvent): void;
+    /**
+     * Initialization of progressBar after changing of product etc.
+     * @param calendar
+     * @returns
+     */
+    protected setCal(calendar: Calendar | null): void;
+    private render;
+    private ontstamp;
+}

package/types/BindedCheckbox.d.ts

@@ -0,0 +1,30 @@
+import type { DataSpecifications } from '@windy/dataSpecifications.d';
+type BindedCheckboxInitParams<T extends keyof DataSpecifications> = {
+    el: HTMLElement;
+    bindStore: T;
+    onValue?: DataSpecifications[T]['def'];
+    offValue?: DataSpecifications[T]['def'];
+};
+export declare class BindedCheckbox<T extends keyof DataSpecifications> {
+    /**
+     * Element in DOM
+     */
+    private el;
+    /**
+     * Store item binded to this DOM el
+     */
+    private bindStore;
+    /**
+     * What kind of value is considered ON in the store
+     */
+    private onValue;
+    /**
+     * What kind of value is considered OFF in the store
+     */
+    private offValue;
+    constructor(params: BindedCheckboxInitParams<T>);
+    unmount(): void;
+    toggle(): void;
+    private set;
+}
+export {};

package/types/BindedSwitch.d.ts

@@ -0,0 +1,35 @@
+import { Switch } from '@windy/Switch';
+import type { DataSpecifications } from '@windy/dataSpecifications.d';
+import type { SwitchInitParams } from '@windy/Switch';
+export type BindedSwitchInitParams<T extends keyof DataSpecifications> = {
+    bindStore: T;
+} & SwitchInitParams<DataSpecifications[T]['def']>;
+/**
+ * BindedSwitch is a switch that is bound to a store item.
+ * When the store item changes, the switch is updated.
+ * When the switch is clicked, the store item is updated.
+ */
+export declare class BindedSwitch<T extends keyof DataSpecifications> extends Switch<DataSpecifications[T]['def']> {
+    /**
+     * Ident of store item to bind switch with
+     */
+    bindStore: T;
+    constructor(params: BindedSwitchInitParams<T>);
+    unmount(): void;
+    set(value: DataSpecifications[T]['def'], _uiIdent?: string | void): void;
+    /**
+     * Handles the click event for the BindedSwitch component.
+     * @param command - The command to execute.
+     * @param value - The value to pass to the command.
+     */
+    click(command: string, value: string | DataSpecifications[T]['def']): void;
+    /**
+     * Optional method to re-render itself
+     */
+    render?(): void;
+    /**
+     * Optional redraw used in some instances
+     */
+    protected redraw?(): void;
+    protected getEl(value: DataSpecifications[T]['def']): HTMLElement | null;
+}

package/types/BottomSlide.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Slides plugin from bootm on mobile
+ *
+ * @example
+ *  if( rs.isMobile ) {
+ *
+ *    new BottomSlide({
+ *        el: this.refs.handler, // Sensitive handler
+ *        pluginEl: this.node, // El of plugin
+ *        pluginName: 'articles',
+ *    })
+ * }
+ */
+import { Drag } from '@windy/Drag';
+import { Swipe } from '@windy/Swipe';
+import type { DragInitParams } from '@windy/Drag';
+import type { Plugins } from '@windy/plugins.d';
+export type BottomSlideInitParams = {
+    pluginEl: HTMLElement;
+    pluginName: keyof Plugins;
+    scrollEl?: HTMLElement;
+    closeOnSwipeDown?: boolean;
+} & DragInitParams;
+export declare class BottomSlide extends Drag {
+    /**
+     * DOM element with plugin itself
+     */
+    private pluginEl;
+    /**
+     * Ident of plugin
+     */
+    private pluginName;
+    /**
+     * Which elemnt should handle the scroll
+     */
+    private scrollEl?;
+    /**
+     * Swiping on whole element down cause closing el
+     */
+    private closeOnSwipeDown?;
+    private threshold;
+    protected swipeHandler: Swipe;
+    private startY;
+    private transformedY;
+    private throttledY;
+    private difference;
+    constructor(params: BottomSlideInitParams);
+    ondrag(_x: number, y: number, e: Event): void;
+    ondragend(): void;
+    startDrag(e: TouchEvent): void;
+    private initCloseOnSwipeDown;
+    private updatePosition;
+}

package/types/BottomTagPlugin.d.ts

@@ -0,0 +1,8 @@
+import { WindowPlugin } from '@windy/WindowPlugin';
+import type { WindowPluginInitParams } from '@windy/WindowPlugin';
+import type { BottomTagPlugins } from '@windy/plugins.d';
+export type BottomTagPluginInitParams<P extends keyof BottomTagPlugins> = Omit<WindowPluginInitParams<P>, 'ident'> & Pick<BottomTagPlugin<P>, 'ident'>;
+export declare class BottomTagPlugin<P extends keyof BottomTagPlugins> extends WindowPlugin<P> {
+    ident: P;
+    constructor(params: BottomTagPluginInitParams<P>);
+}