tasmota-esp-web-tools 8.1.0

package/dist/const.d.ts

@@ -0,0 +1,94 @@
+export interface Logger {
+    log(msg: string, ...args: any[]): void;
+    error(msg: string, ...args: any[]): void;
+    debug(msg: string, ...args: any[]): void;
+}
+export interface Build {
+    chipFamily: "ESP32" | "ESP8266" | "ESP32-S2" | "ESP32-S3" | "ESP32-C3";
+    parts: {
+        path: string;
+        offset: number;
+    }[];
+}
+export interface Manifest {
+    name: string;
+    version: string;
+    home_assistant_domain?: string;
+    funding_url?: string;
+    /** @deprecated use `new_install_prompt_erase` instead */
+    new_install_skip_erase?: boolean;
+    new_install_prompt_erase?: boolean;
+    new_install_improv_wait_time?: number;
+    builds: Build[];
+}
+export interface BaseFlashState {
+    state: FlashStateType;
+    message: string;
+    manifest?: Manifest;
+    build?: Build;
+    chipFamily?: Build["chipFamily"] | "Unknown Chip";
+}
+export interface InitializingState extends BaseFlashState {
+    state: FlashStateType.INITIALIZING;
+    details: {
+        done: boolean;
+    };
+}
+export interface ManifestState extends BaseFlashState {
+    state: FlashStateType.MANIFEST;
+    details: {
+        done: boolean;
+    };
+}
+export interface PreparingState extends BaseFlashState {
+    state: FlashStateType.PREPARING;
+    details: {
+        done: boolean;
+    };
+}
+export interface ErasingState extends BaseFlashState {
+    state: FlashStateType.ERASING;
+    details: {
+        done: boolean;
+    };
+}
+export interface WritingState extends BaseFlashState {
+    state: FlashStateType.WRITING;
+    details: {
+        bytesTotal: number;
+        bytesWritten: number;
+        percentage: number;
+    };
+}
+export interface FinishedState extends BaseFlashState {
+    state: FlashStateType.FINISHED;
+}
+export interface ErrorState extends BaseFlashState {
+    state: FlashStateType.ERROR;
+    details: {
+        error: FlashError;
+        details: string | Error;
+    };
+}
+export type FlashState = InitializingState | ManifestState | PreparingState | ErasingState | WritingState | FinishedState | ErrorState;
+export declare const enum FlashStateType {
+    INITIALIZING = "initializing",
+    MANIFEST = "manifest",
+    PREPARING = "preparing",
+    ERASING = "erasing",
+    WRITING = "writing",
+    FINISHED = "finished",
+    ERROR = "error"
+}
+export declare const enum FlashError {
+    FAILED_INITIALIZING = "failed_initialize",
+    FAILED_MANIFEST_FETCH = "fetch_manifest_failed",
+    NOT_SUPPORTED = "not_supported",
+    FAILED_FIRMWARE_DOWNLOAD = "failed_firmware_download",
+    WRITE_FAILED = "write_failed"
+}
+declare global {
+    interface HTMLElementEventMap {
+        "state-changed": CustomEvent<FlashState>;
+    }
+}

package/dist/const.js

@@ -0,0 +1 @@
+export {};

package/dist/flash.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="w3c-web-serial" />
+import { Logger } from "tasmota-webserial-esptool";
+import { FlashState } from "./const";
+export declare const flash: (onEvent: (state: FlashState) => void, port: SerialPort, logger: Logger, manifestPath: string, eraseFirst: boolean) => Promise<void>;

package/dist/flash.js

@@ -0,0 +1,191 @@
+import { ESPLoader } from "tasmota-webserial-esptool";
+import { getChipFamilyName } from "./util/chip-family-name";
+import { sleep } from "./util/sleep";
+export const flash = async (onEvent, port, logger, manifestPath, eraseFirst) => {
+    let manifest;
+    let build;
+    let chipFamily;
+    const fireStateEvent = (stateUpdate) => onEvent({
+        ...stateUpdate,
+        manifest,
+        build,
+        chipFamily,
+    });
+    const manifestURL = new URL(manifestPath, location.toString()).toString();
+    const manifestProm = fetch(manifestURL).then((resp) => resp.json());
+    const esploader = new ESPLoader(port, logger);
+    // For debugging
+    window.esploader = esploader;
+    fireStateEvent({
+        state: "initializing" /* FlashStateType.INITIALIZING */,
+        message: "Initializing...",
+        details: { done: false },
+    });
+    try {
+        await esploader.initialize();
+    }
+    catch (err) {
+        logger.error(err);
+        fireStateEvent({
+            state: "error" /* FlashStateType.ERROR */,
+            message: "Failed to initialize. Try resetting your device or holding the BOOT button while clicking INSTALL.",
+            details: { error: "failed_initialize" /* FlashError.FAILED_INITIALIZING */, details: err },
+        });
+        if (esploader.connected) {
+            await esploader.disconnect();
+        }
+        return;
+    }
+    chipFamily = getChipFamilyName(esploader);
+    fireStateEvent({
+        state: "initializing" /* FlashStateType.INITIALIZING */,
+        message: `Initialized. Found ${chipFamily}`,
+        details: { done: true },
+    });
+    fireStateEvent({
+        state: "manifest" /* FlashStateType.MANIFEST */,
+        message: "Fetching manifest...",
+        details: { done: false },
+    });
+    try {
+        manifest = await manifestProm;
+    }
+    catch (err) {
+        fireStateEvent({
+            state: "error" /* FlashStateType.ERROR */,
+            message: `Unable to fetch manifest: ${err}`,
+            details: { error: "fetch_manifest_failed" /* FlashError.FAILED_MANIFEST_FETCH */, details: err },
+        });
+        await esploader.disconnect();
+        return;
+    }
+    build = manifest.builds.find((b) => b.chipFamily === chipFamily);
+    fireStateEvent({
+        state: "manifest" /* FlashStateType.MANIFEST */,
+        message: `Found manifest for ${manifest.name}`,
+        details: { done: true },
+    });
+    if (!build) {
+        fireStateEvent({
+            state: "error" /* FlashStateType.ERROR */,
+            message: `Your ${chipFamily} board is not supported.`,
+            details: { error: "not_supported" /* FlashError.NOT_SUPPORTED */, details: chipFamily },
+        });
+        await esploader.disconnect();
+        return;
+    }
+    fireStateEvent({
+        state: "preparing" /* FlashStateType.PREPARING */,
+        message: "Preparing installation...",
+        details: { done: false },
+    });
+    const filePromises = build.parts.map(async (part) => {
+        const url = new URL(part.path, manifestURL).toString();
+        const resp = await fetch(url);
+        if (!resp.ok) {
+            throw new Error(`Downlading firmware ${part.path} failed: ${resp.status}`);
+        }
+        return resp.arrayBuffer();
+    });
+    // Run the stub while we wait for files to download
+    const espStub = await esploader.runStub();
+    const files = [];
+    let totalSize = 0;
+    for (const prom of filePromises) {
+        try {
+            const data = await prom;
+            files.push(data);
+            totalSize += data.byteLength;
+        }
+        catch (err) {
+            fireStateEvent({
+                state: "error" /* FlashStateType.ERROR */,
+                message: err.message,
+                details: {
+                    error: "failed_firmware_download" /* FlashError.FAILED_FIRMWARE_DOWNLOAD */,
+                    details: err.message,
+                },
+            });
+            await esploader.disconnect();
+            return;
+        }
+    }
+    fireStateEvent({
+        state: "preparing" /* FlashStateType.PREPARING */,
+        message: "Installation prepared",
+        details: { done: true },
+    });
+    if (eraseFirst) {
+        fireStateEvent({
+            state: "erasing" /* FlashStateType.ERASING */,
+            message: "Erasing device...",
+            details: { done: false },
+        });
+        await espStub.eraseFlash();
+        fireStateEvent({
+            state: "erasing" /* FlashStateType.ERASING */,
+            message: "Device erased",
+            details: { done: true },
+        });
+    }
+    let lastPct = 0;
+    fireStateEvent({
+        state: "writing" /* FlashStateType.WRITING */,
+        message: `Writing progress: ${lastPct}%`,
+        details: {
+            bytesTotal: totalSize,
+            bytesWritten: 0,
+            percentage: lastPct,
+        },
+    });
+    let totalWritten = 0;
+    for (const part of build.parts) {
+        const file = files.shift();
+        try {
+            await espStub.flashData(file, (bytesWritten) => {
+                const newPct = Math.floor(((totalWritten + bytesWritten) / totalSize) * 100);
+                if (newPct === lastPct) {
+                    return;
+                }
+                lastPct = newPct;
+                fireStateEvent({
+                    state: "writing" /* FlashStateType.WRITING */,
+                    message: `Writing progress: ${newPct}%`,
+                    details: {
+                        bytesTotal: totalSize,
+                        bytesWritten: totalWritten + bytesWritten,
+                        percentage: newPct,
+                    },
+                });
+            }, part.offset, true);
+        }
+        catch (err) {
+            fireStateEvent({
+                state: "error" /* FlashStateType.ERROR */,
+                message: err.message,
+                details: { error: "write_failed" /* FlashError.WRITE_FAILED */, details: err },
+            });
+            await esploader.disconnect();
+            return;
+        }
+        totalWritten += file.byteLength;
+    }
+    fireStateEvent({
+        state: "writing" /* FlashStateType.WRITING */,
+        message: "Writing complete",
+        details: {
+            bytesTotal: totalSize,
+            bytesWritten: totalWritten,
+            percentage: 100,
+        },
+    });
+    await sleep(100);
+    console.log("DISCONNECT");
+    await esploader.disconnect();
+    console.log("HARD RESET");
+    await esploader.hardReset();
+    fireStateEvent({
+        state: "finished" /* FlashStateType.FINISHED */,
+        message: "All done!",
+    });
+};

package/dist/install-button.d.ts

@@ -0,0 +1,17 @@
+import type { FlashState } from "./const";
+import type { EwtInstallDialog } from "./install-dialog";
+export declare class InstallButton extends HTMLElement {
+    static isSupported: boolean;
+    static isAllowed: boolean;
+    private static style;
+    manifest?: string;
+    eraseFirst?: boolean;
+    hideProgress?: boolean;
+    showLog?: boolean;
+    logConsole?: boolean;
+    state?: FlashState;
+    renderRoot?: ShadowRoot;
+    overrides: EwtInstallDialog["overrides"];
+    static preload(): void;
+    connectedCallback(): void;
+}

package/dist/install-button.js

@@ -0,0 +1,96 @@
+export class InstallButton extends HTMLElement {
+    static preload() {
+        import("./connect");
+    }
+    connectedCallback() {
+        if (this.renderRoot) {
+            return;
+        }
+        this.renderRoot = this.attachShadow({ mode: "open" });
+        if (!InstallButton.isSupported || !InstallButton.isAllowed) {
+            this.toggleAttribute("install-unsupported", true);
+            this.renderRoot.innerHTML = !InstallButton.isAllowed
+                ? "<slot name='not-allowed'>You can only install ESP devices on HTTPS websites or on the localhost.</slot>"
+                : "<slot name='unsupported'>Your browser does not support installing things on ESP devices. Use Google Chrome or Microsoft Edge.</slot>";
+            return;
+        }
+        this.toggleAttribute("install-supported", true);
+        this.addEventListener("mouseover", InstallButton.preload);
+        const slot = document.createElement("slot");
+        slot.addEventListener("click", async (ev) => {
+            ev.preventDefault();
+            const mod = await import("./connect");
+            mod.connect(this);
+        });
+        slot.name = "activate";
+        const button = document.createElement("button");
+        button.innerText = "CONNECT";
+        slot.append(button);
+        if ("adoptedStyleSheets" in Document.prototype &&
+            "replaceSync" in CSSStyleSheet.prototype) {
+            const sheet = new CSSStyleSheet();
+            sheet.replaceSync(InstallButton.style);
+            this.renderRoot.adoptedStyleSheets = [sheet];
+        }
+        else {
+            const styleSheet = document.createElement("style");
+            styleSheet.innerText = InstallButton.style;
+            this.renderRoot.append(styleSheet);
+        }
+        this.renderRoot.append(slot);
+    }
+}
+InstallButton.isSupported = "serial" in navigator;
+InstallButton.isAllowed = window.isSecureContext;
+InstallButton.style = `
+  button {
+    position: relative;
+    cursor: pointer;
+    font-size: 14px;
+    padding: 8px 28px;
+    color: var(--esp-tools-button-text-color, #fff);
+    background-color: var(--esp-tools-button-color, #03a9f4);
+    border: none;
+    border-radius: 4px;
+    box-shadow: 0 2px 2px 0 rgba(0,0,0,.14), 0 3px 1px -2px rgba(0,0,0,.12), 0 1px 5px 0 rgba(0,0,0,.2);
+  }
+  button::before {
+    content: " ";
+    position: absolute;
+    top: 0;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    opacity: 0.2;
+    border-radius: 4px;
+  }
+  button:hover {
+    box-shadow: 0 4px 8px 0 rgba(0,0,0,.14), 0 1px 7px 0 rgba(0,0,0,.12), 0 3px 1px -1px rgba(0,0,0,.2);
+  }
+  button:hover::before {
+    background-color: rgba(255,255,255,.8);
+  }
+  button:focus {
+    outline: none;
+  }
+  button:focus::before {
+    background-color: white;
+  }
+  button:active::before {
+    background-color: grey;
+  }
+  :host([active]) button {
+    color: rgba(0, 0, 0, 0.38);
+    background-color: rgba(0, 0, 0, 0.12);
+    box-shadow: none;
+    cursor: unset;
+    pointer-events: none;
+  }
+  improv-wifi-launch-button {
+    display: block;
+    margin-top: 16px;
+  }
+  .hidden {
+    display: none;
+  }`;
+customElements.define("esp-web-install-button", InstallButton);

package/dist/install-dialog.d.ts

@@ -0,0 +1,70 @@
+/// <reference types="w3c-web-serial" />
+import { LitElement, PropertyValues, TemplateResult } from "lit";
+import "./components/ewt-button";
+import "./components/ewt-checkbox";
+import "./components/ewt-console";
+import "./components/ewt-dialog";
+import "./components/ewt-formfield";
+import "./components/ewt-icon-button";
+import "./components/ewt-textfield";
+import "./components/ewt-select";
+import "./components/ewt-list-item";
+import "./pages/ewt-page-progress";
+import "./pages/ewt-page-message";
+import { Logger, Manifest } from "./const.js";
+import { ImprovSerial } from "improv-wifi-serial-sdk/dist/serial";
+export declare class EwtInstallDialog extends LitElement {
+    port: SerialPort;
+    manifestPath: string;
+    logger: Logger;
+    overrides?: {
+        checkSameFirmware?: (manifest: Manifest, deviceImprov: ImprovSerial["info"]) => boolean;
+    };
+    private _manifest;
+    private _info?;
+    private _client?;
+    private _state;
+    private _installErase;
+    private _installConfirmed;
+    private _installState?;
+    private _provisionForce;
+    private _wasProvisioned;
+    private _error?;
+    private _busy;
+    private _ssids?;
+    private _selectedSsid;
+    protected render(): TemplateResult<1>;
+    _renderProgress(label: string | TemplateResult, progress?: number): TemplateResult<1>;
+    _renderError(label: string): [string, TemplateResult, boolean];
+    _renderDashboard(): [string, TemplateResult, boolean, boolean];
+    _renderDashboardNoImprov(): [string, TemplateResult, boolean, boolean];
+    _renderProvision(): [string | undefined, TemplateResult, boolean];
+    _renderAskErase(): [string | undefined, TemplateResult];
+    _renderInstall(): [string | undefined, TemplateResult, boolean, boolean];
+    _renderLogs(): [string | undefined, TemplateResult, boolean];
+    willUpdate(changedProps: PropertyValues): void;
+    protected firstUpdated(changedProps: PropertyValues): void;
+    protected updated(changedProps: PropertyValues): void;
+    private _focusFormElement;
+    private _initialize;
+    private _startInstall;
+    private _confirmInstall;
+    private _doProvision;
+    private _handleDisconnect;
+    private _handleClose;
+    /**
+     * Return if the device runs same firmware as manifest.
+     */
+    private get _isSameFirmware();
+    /**
+     * Return if the device runs same firmware and version as manifest.
+     */
+    private get _isSameVersion();
+    private _closeClientWithoutEvents;
+    static styles: import("lit").CSSResult[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "ewt-install-dialog": EwtInstallDialog;
+    }
+}