poe-svelte-ui-lib 1.61.0 → 1.63.0

package/README.md

@@ -59,6 +59,8 @@ npm install poe-svelte-ui-lib
 
 **Названия смарт-виджетов** — в словаре библиотеки на всех языках (WiFi, «Об устройстве», «Файловая система», «Стек и задачи», «RGB лента», «Пилотажный дисплей», «Карта»); пустой `label.name` показывает название на языке пользователя, `widgetTitle(type)` отдаёт его сразу на всех языках `{ ru, en, zh }` — так конструктор заполняет заголовок нового виджета.
 
+**Ядро протоколов** — `poe-svelte-ui-lib/protocols` (без Svelte, работает и под Node без Vite): общий для DevCloud, WebApp и SYP-DevTerminal CBOR-кодек (RFC 8949) — `encodeCbor`/`decodeCbor`, `CborEncoder`/`CborDecoder`; `valueToCbor`/`cborToValue` — обычные значения, двоичные данные как `Uint8Array` (WebSocket, хранилище, телеметрия); `jsonToCbor`/`cborToJson` — JSON-совместимые значения, двоичные данные в base64, строки под ключами с `BIN` — байты (поля ввода терминала и отладки). Пакет `poe_cbor_pkt` `{ TrgBusID : [RetBusID, HA_Code, Payload, CRC16] }` (CAN, RS485): `encodePacket`/`decodePacket` (разбор с начала буфера — `complete` с длиной, `incomplete` для потока или `garbage`; объекты с одинаковым `TrgBusID` не склеиваются, неверный CRC — флаг `crcOk`), `objectsFor` (свой адрес и broadcast `0xFFFF`), `makeHaCode`/`splitHaCode`, `packetObjectCrc`; контрольные суммы `crc16Kermit` и `crc8Rohc`. Байты совпадают с `poe_cbor_pkt.c` прошивки — проверка `npm run TestProtocols` (`tests/protocols.test.mjs`, эталонные пакеты собраны прошивочным кодом). Дальше сюда переезжает разбор потоков POESerial/CAN/RS485 — своих копий протоколов в приложениях не держим.
+
 **Шапка смарт-виджета** (`WidgetHeader`): значок, заголовок и сворачивание слева, «?» в правом краю; правая часть (режимы, «Обновить» и т. п.) стоит в той же строке, а если не помещается — уходит второй строкой под заголовок и там переносится.
 
 **Подсказки смарт-виджетов** — `hints.ts`: у каждого виджета своя кнопка «?» в правом краю шапки (`WidgetHeader` с пропом `hints`), по умолчанию подсказки выключены, выбор оператора запоминается в браузере для виджетов этого типа (`hintsSetting("WidgetPFD")`, ключ `localStorage` `WidgetHints.<тип>`, пишется только по нажатию «?»), глобального переключателя нет. Элемент получает подсказку действием `use:hint={{ text, enabled: $hints }}` — всплывающее окно в стиле темы над элементом; тексты — в словаре библиотеки (`widget.*.hint.*`), только там, где смысл поля не очевиден.
@@ -141,7 +143,7 @@ npm run Formatting  # prettier --write .
 
 Связь настраивается на npmjs.com → пакет → Settings → Trusted Publisher: GitHub Actions, `Oleg-Perevyshin/ElementsUI`, workflow `npm_publish.yaml`, разрешение «npm publish». Новая связь подтверждается первой успешной публикацией и должна пройти её в течение 2 дней, иначе истекает. Существующую связь изменить нельзя — только удалить и создать заново.
 
-**Обновление DevCloud — автоматически.** После публикации job `update-devcloud` того же workflow ждёт новую версию в npm, клонирует `xPOE-Studio/DevCloud` (Forgejo) по секрету `DEVCLOUD_ACCESS_TOKEN` (токен Forgejo с правом записи в репозиторий), ставит `poe-svelte-ui-lib@<версия>`, прогоняет `svelte-kit sync`, `prisma generate` (с заглушкой `DATABASE_URL`, к БД не подключается) и `svelte-check` и, если проверка прошла, пушит в `main` коммит `poe-svelte-ui-lib <версия> [deploy]` — облако разворачивается само. Вручную версию в облаке не поднимаем; изменения кода облака, которым нужна новая версия библиотеки, коммитятся без `[deploy]` до выпуска — их развернёт этот коммит. Если `svelte-check` упал, коммита нет, облако остаётся на прежней версии (смотрите лог job в GitHub Actions).
+**Обновление DevCloud — автоматически.** После публикации job `update-devcloud` того же workflow ждёт новую версию в npm, клонирует `xPOE-Studio/DevCloud` (Forgejo) по секрету `DEVCLOUD_ACCESS_TOKEN` (токен Forgejo с правом записи в репозиторий), ставит `poe-svelte-ui-lib@<версия>`, прогоняет `svelte-kit sync`, `prisma generate` (с заглушкой `DATABASE_URL`, к БД не подключается) и `svelte-check` и, если проверка прошла, пушит в `main` коммит «Автообновление poe-svelte-ui-lib до <версия> — переразвёртывание облака [deploy]» с пояснением, что он создан автоматически при выпуске библиотеки, — облако разворачивается само. Вручную версию в облаке не поднимаем; изменения кода облака, которым нужна новая версия библиотеки, коммитятся без `[deploy]` до выпуска — их развернёт этот коммит. Если `svelte-check` упал, коммита нет, облако остаётся на прежней версии (смотрите лог job в GitHub Actions).
 
 ---
 

package/dist/protocols/cbor/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function bytesToBase64(data: Uint8Array): string;
+export declare function base64ToBytes(data: string): Uint8Array;

package/dist/protocols/cbor/base64.js

@@ -0,0 +1,18 @@
+/* Преобразование массива байт в строку base64 */
+export function bytesToBase64(data) {
+    let binary = "";
+    const len = data.length;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(data[i]);
+    }
+    return btoa(binary);
+}
+/* Преобразование строки base64 в массив байт Uint8Array */
+export function base64ToBytes(data) {
+    const binaryString = atob(data);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}

package/dist/protocols/cbor/decoder.d.ts

@@ -0,0 +1,33 @@
+import { type CborValue } from "./types.js";
+export declare class CborDecoder {
+    private state;
+    constructor(buffer: ArrayBuffer | Uint8Array);
+    get offset(): number;
+    decode(): CborValue;
+    skipValue(): boolean;
+    decodeBytes(): {
+        value: Uint8Array;
+        length: number;
+    } | null;
+    private readIndefiniteBytes;
+    private readIndefiniteString;
+    private decodeStringWithLength;
+    private decodeBytesWithLength;
+    private readHeader;
+    private decodeByType;
+    private skipByType;
+    private decodeArray;
+    private decodeMap;
+    private decodeTag;
+    private decodeSimple;
+    private readUint8;
+    private peekUint8;
+    private readUint16;
+    private readUint32;
+    private readUint64;
+    private hasBytes;
+    private bitsToFloat16;
+    private bitsToFloat32;
+    private bitsToFloat64;
+}
+export declare function decodeCbor(buffer: ArrayBuffer | Uint8Array): CborValue;

package/dist/protocols/cbor/decoder.js

@@ -0,0 +1,445 @@
+/* CBOR декодер - реализует декодирование бинарного формата CBOR (RFC 8949) */
+import { CborMajorType, CborAdditionalInfo, CborSimpleValue, CborTag, CBOR_BREAK, CBOR_MAX_DEPTH, CborError, CborEndOfDataError, CborDepthLimitError, } from "./types.js";
+/* Класс декодера CBOR */
+export class CborDecoder {
+    state;
+    constructor(buffer) {
+        const uint8Array = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+        this.state = {
+            buffer: new DataView(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteLength),
+            offset: 0,
+            length: uint8Array.byteLength,
+            depth: 0,
+        };
+    }
+    /* Сколько байт уже прочитано — граница значения при разборе потока по одному значению */
+    get offset() {
+        return this.state.offset;
+    }
+    /* Основной метод декодирования - декодирует одно значение CBOR */
+    decode() {
+        this.state.depth++;
+        if (this.state.depth > CBOR_MAX_DEPTH) {
+            this.state.depth--;
+            throw new CborDepthLimitError();
+        }
+        try {
+            const header = this.readHeader();
+            const value = this.decodeByType(header);
+            this.state.depth--;
+            return value;
+        }
+        catch (error) {
+            this.state.depth--;
+            throw error;
+        }
+    }
+    /* Пропустить текущее значение CBOR */
+    skipValue() {
+        this.state.depth++;
+        if (this.state.depth > CBOR_MAX_DEPTH) {
+            this.state.depth--;
+            return false;
+        }
+        try {
+            const header = this.readHeader();
+            const result = this.skipByType(header);
+            this.state.depth--;
+            return result;
+        }
+        catch {
+            this.state.depth--;
+            return false;
+        }
+    }
+    /* Декодировать байтовую строку (в т.ч. indefinite-length, через чанки) */
+    decodeBytes() {
+        const savedOffset = this.state.offset;
+        try {
+            const header = this.readHeader();
+            if (header.majorType !== CborMajorType.ByteString) {
+                this.state.offset = savedOffset;
+                return null;
+            }
+            const result = header.value === BigInt(-1) ? this.readIndefiniteBytes() : this.decodeBytesWithLength(Number(header.value));
+            if (!result) {
+                this.state.offset = savedOffset;
+                return null;
+            }
+            return result;
+        }
+        catch {
+            this.state.offset = savedOffset;
+            return null;
+        }
+    }
+    /* Читает чанки indefinite-length байтовой строки до BREAK и склеивает их (заголовок уже прочитан вызывающим) */
+    readIndefiniteBytes() {
+        const chunks = [];
+        let totalLength = 0;
+        while (this.state.offset < this.state.length) {
+            if (this.peekUint8() === CBOR_BREAK) {
+                this.readUint8();
+                break;
+            }
+            const chunk = this.decodeBytes();
+            if (!chunk)
+                return null;
+            chunks.push(chunk.value);
+            totalLength += chunk.length;
+        }
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return { value: result, length: totalLength };
+    }
+    /* Читает чанки indefinite-length текстовой строки до BREAK и склеивает их (заголовок уже прочитан вызывающим) */
+    readIndefiniteString() {
+        let value = "";
+        let totalLength = 0;
+        while (this.state.offset < this.state.length) {
+            if (this.peekUint8() === CBOR_BREAK) {
+                this.readUint8();
+                break;
+            }
+            const chunkHeader = this.readHeader();
+            if (chunkHeader.majorType !== CborMajorType.Utf8String || chunkHeader.value === BigInt(-1))
+                return null;
+            const chunk = this.decodeStringWithLength(Number(chunkHeader.value));
+            if (!chunk)
+                return null;
+            value += chunk.value;
+            totalLength += chunk.length;
+        }
+        return { value, length: totalLength };
+    }
+    /* Декодировать строку с известной длиной (внутренний метод) */
+    decodeStringWithLength(length) {
+        try {
+            if (!this.hasBytes(length)) {
+                return null;
+            }
+            const bytes = new Uint8Array(this.state.buffer.buffer, this.state.buffer.byteOffset + this.state.offset, length);
+            const value = new TextDecoder().decode(bytes);
+            this.state.offset += length;
+            return { value, length };
+        }
+        catch {
+            return null;
+        }
+    }
+    /* Декодировать байтовую строку с известной длиной (внутренний метод) */
+    decodeBytesWithLength(length) {
+        try {
+            if (!this.hasBytes(length)) {
+                return null;
+            }
+            const value = new Uint8Array(this.state.buffer.buffer, this.state.buffer.byteOffset + this.state.offset, length);
+            this.state.offset += length;
+            return { value, length };
+        }
+        catch {
+            return null;
+        }
+    }
+    /* Прочитать заголовок CBOR (первый байт) */
+    readHeader() {
+        const first = this.readUint8();
+        const majorType = first >> 5;
+        const additional = first & 0x1f;
+        let value;
+        if (additional < CborAdditionalInfo.NumByte) {
+            /* Значение в дополнительных битах */
+            value = BigInt(additional);
+        }
+        else if (additional === CborAdditionalInfo.Indefinite) {
+            value = BigInt(-1);
+        }
+        else if (additional === CborAdditionalInfo.NumByte) {
+            value = BigInt(this.readUint8());
+        }
+        else if (additional === CborAdditionalInfo.Float16) {
+            value = BigInt(this.readUint16());
+        }
+        else if (additional === CborAdditionalInfo.Float32) {
+            value = BigInt(this.readUint32());
+        }
+        else if (additional === CborAdditionalInfo.Float64) {
+            value = this.readUint64();
+        }
+        else {
+            throw new CborError(`Unknown additional info: ${additional}`);
+        }
+        return { majorType: majorType, additional, value };
+    }
+    /* Декодировать значение по типу заголовка */
+    decodeByType(header) {
+        switch (header.majorType) {
+            case CborMajorType.UnsignedInteger:
+                return Number(header.value);
+            case CborMajorType.NegativeInteger:
+                return -1 - Number(header.value);
+            case CborMajorType.ByteString: {
+                const bytesValue = header.value === BigInt(-1) ? this.readIndefiniteBytes() : this.decodeBytesWithLength(Number(header.value));
+                /* Не хватило байт — конец данных (в потоке это «ждать ещё»), а не испорченный CBOR */
+                if (!bytesValue)
+                    throw new CborEndOfDataError();
+                return bytesValue.value;
+            }
+            case CborMajorType.Utf8String: {
+                const stringValue = header.value === BigInt(-1) ? this.readIndefiniteString() : this.decodeStringWithLength(Number(header.value));
+                if (!stringValue)
+                    throw new CborEndOfDataError();
+                return stringValue.value;
+            }
+            case CborMajorType.Array:
+                return this.decodeArray(header);
+            case CborMajorType.Map:
+                return this.decodeMap(header);
+            case CborMajorType.Tag:
+                return this.decodeTag(header);
+            case CborMajorType.Simple:
+                return this.decodeSimple(header);
+            default:
+                throw new CborError(`Unknown major type: ${header.majorType}`);
+        }
+    }
+    /* Пропустить значение по типу */
+    skipByType(header) {
+        switch (header.majorType) {
+            case CborMajorType.UnsignedInteger:
+            case CborMajorType.NegativeInteger:
+                return true;
+            case CborMajorType.ByteString:
+            case CborMajorType.Utf8String:
+                if (header.value === BigInt(-1)) {
+                    /* Indefinite length - пропускаем до break */
+                    while (this.state.offset < this.state.length) {
+                        if (this.peekUint8() === CBOR_BREAK) {
+                            this.readUint8();
+                            return true;
+                        }
+                        if (!this.skipValue())
+                            return false;
+                    }
+                    return false;
+                }
+                return this.hasBytes(Number(header.value)) ? ((this.state.offset += Number(header.value)), true) : false;
+            case CborMajorType.Array:
+                if (header.value === BigInt(-1)) {
+                    while (this.state.offset < this.state.length) {
+                        if (this.peekUint8() === CBOR_BREAK) {
+                            this.readUint8();
+                            return true;
+                        }
+                        if (!this.skipValue())
+                            return false;
+                    }
+                    return false;
+                }
+                for (let i = 0; i < Number(header.value); i++) {
+                    if (!this.skipValue())
+                        return false;
+                }
+                return true;
+            case CborMajorType.Map:
+                if (header.value === BigInt(-1)) {
+                    while (this.state.offset < this.state.length) {
+                        if (this.peekUint8() === CBOR_BREAK) {
+                            this.readUint8();
+                            return true;
+                        }
+                        if (!this.skipValue())
+                            return false;
+                        if (!this.skipValue())
+                            return false;
+                    }
+                    return false;
+                }
+                for (let i = 0; i < Number(header.value); i++) {
+                    if (!this.skipValue())
+                        return false;
+                    if (!this.skipValue())
+                        return false;
+                }
+                return true;
+            case CborMajorType.Tag:
+                return this.skipValue();
+            case CborMajorType.Simple:
+                if (header.value >= BigInt(24) && header.value <= BigInt(27)) {
+                    const bytes = [2, 4, 8][Number(header.value) - 24];
+                    return this.hasBytes(bytes) ? ((this.state.offset += bytes), true) : false;
+                }
+                return true;
+            default:
+                return false;
+        }
+    }
+    /* Декодировать массив */
+    decodeArray(header) {
+        if (header.value === BigInt(-1)) {
+            /* Indefinite length */
+            const result = [];
+            while (this.state.offset < this.state.length) {
+                if (this.peekUint8() === CBOR_BREAK) {
+                    this.readUint8();
+                    break;
+                }
+                result.push(this.decode());
+            }
+            return result;
+        }
+        const count = Number(header.value);
+        const result = [];
+        for (let i = 0; i < count; i++) {
+            result.push(this.decode());
+        }
+        return result;
+    }
+    /* Декодировать словарь (map) */
+    decodeMap(header) {
+        if (header.value === BigInt(-1)) {
+            /* Indefinite length */
+            const result = new Map();
+            while (this.state.offset < this.state.length) {
+                if (this.peekUint8() === CBOR_BREAK) {
+                    this.readUint8();
+                    break;
+                }
+                const key = this.decode();
+                const value = this.decode();
+                result.set(key, value);
+            }
+            return result;
+        }
+        const count = Number(header.value);
+        const result = new Map();
+        for (let i = 0; i < count; i++) {
+            const key = this.decode();
+            const value = this.decode();
+            result.set(key, value);
+        }
+        return result;
+    }
+    /* Декодировать тег */
+    decodeTag(header) {
+        const tagValue = header.value;
+        const taggedValue = this.decode();
+        return new CborTag(Number(tagValue), taggedValue);
+    }
+    /* Декодировать простое значение */
+    decodeSimple(header) {
+        const additional = header.additional;
+        const value = header.value;
+        if (additional === CborSimpleValue.False)
+            return false;
+        if (additional === CborSimpleValue.True)
+            return true;
+        if (additional === CborSimpleValue.Null)
+            return null;
+        if (additional === CborSimpleValue.Undefined)
+            return null;
+        /* Float types - используем value из заголовка (оно уже содержит биты float) */
+        if (additional === CborAdditionalInfo.Float16) {
+            /* value содержит биты float16 */
+            return this.bitsToFloat16(Number(value));
+        }
+        if (additional === CborAdditionalInfo.Float32) {
+            /* value содержит биты float32 */
+            return this.bitsToFloat32(Number(value));
+        }
+        if (additional === CborAdditionalInfo.Float64) {
+            /* value содержит биты float64 */
+            return this.bitsToFloat64(value);
+        }
+        /* Simple value (0-19, 24-27) */
+        if (additional < 24) {
+            return Number(value);
+        }
+        return Number(value);
+    }
+    /* Вспомогательные методы чтения */
+    /* Прочитать 1 байт */
+    readUint8() {
+        if (this.state.offset >= this.state.length) {
+            throw new CborEndOfDataError();
+        }
+        return this.state.buffer.getUint8(this.state.offset++);
+    }
+    /* Подсмотреть 1 байт без продвижения */
+    peekUint8() {
+        if (this.state.offset >= this.state.length) {
+            throw new CborEndOfDataError();
+        }
+        return this.state.buffer.getUint8(this.state.offset);
+    }
+    /* Прочитать 2 байта (big-endian) */
+    readUint16() {
+        if (this.state.offset + 2 > this.state.length) {
+            throw new CborEndOfDataError();
+        }
+        const value = this.state.buffer.getUint16(this.state.offset, false);
+        this.state.offset += 2;
+        return value;
+    }
+    /* Прочитать 4 байта (big-endian) */
+    readUint32() {
+        if (this.state.offset + 4 > this.state.length) {
+            throw new CborEndOfDataError();
+        }
+        const value = this.state.buffer.getUint32(this.state.offset, false);
+        this.state.offset += 4;
+        return value;
+    }
+    /* Прочитать 8 байт (big-endian) */
+    readUint64() {
+        if (this.state.offset + 8 > this.state.length) {
+            throw new CborEndOfDataError();
+        }
+        const value = this.state.buffer.getBigUint64(this.state.offset, false);
+        this.state.offset += 8;
+        return value;
+    }
+    /* Проверить есть ли n байт в буфере */
+    hasBytes(n) {
+        return this.state.offset + n <= this.state.length;
+    }
+    /* Преобразовать биты в float16 */
+    bitsToFloat16(bits) {
+        const sign = (bits >> 15) & 0x1;
+        const exp = (bits >> 10) & 0x1f;
+        const mant = bits & 0x3ff;
+        if (exp === 0) {
+            return Math.pow(-1, sign) * Math.pow(2, -24) * mant;
+        }
+        if (exp === 31) {
+            if (mant === 0) {
+                return sign ? -Infinity : Infinity;
+            }
+            return NaN;
+        }
+        return Math.pow(-1, sign) * Math.pow(2, exp - 25) * (mant | 0x400);
+    }
+    /* Преобразовать биты в float32 */
+    bitsToFloat32(bits) {
+        const buffer = new ArrayBuffer(4);
+        const view = new DataView(buffer);
+        view.setUint32(0, bits, false);
+        return view.getFloat32(0, false);
+    }
+    /* Преобразовать биты в float64 */
+    bitsToFloat64(bits) {
+        const buffer = new ArrayBuffer(8);
+        const view = new DataView(buffer);
+        view.setBigUint64(0, bits, false);
+        return view.getFloat64(0, false);
+    }
+}
+/* Утилита для декодирования CBOR из буфера */
+export function decodeCbor(buffer) {
+    const decoder = new CborDecoder(buffer);
+    return decoder.decode();
+}

package/dist/protocols/cbor/encoder.d.ts

@@ -0,0 +1,29 @@
+import { type CborValue } from "./types.js";
+export declare class CborEncoder {
+    private buffer;
+    constructor(initialCapacity?: number);
+    getResult(): Uint8Array;
+    encodeNull(): this;
+    encodeBoolean(value: boolean): this;
+    encodeUnsigned(value: number | bigint): this;
+    encodeInt(value: number | bigint): this;
+    encodeFloat32(value: number): this;
+    encodeFloat64(value: number): this;
+    encodeNumber(value: number): this;
+    private canBeFloat16;
+    private float32ToFloat16;
+    private float16ToFloat32;
+    encodeFloat16(value: number): this;
+    encodeString(value: string): this;
+    encodeBytes(value: Uint8Array | number[]): this;
+    encodeArrayStart(count: number | null): this;
+    encodeMapStart(count: number | null): this;
+    encodeBreak(): this;
+    encodeTag(tag: number | bigint): this;
+    encode(value: CborValue): this;
+    private writeIndefiniteHeader;
+    private writeHeader;
+    private bigIntToBytes;
+    private writeBytes;
+}
+export declare function encodeCbor(value: CborValue): Uint8Array;