@mikrojs/firmware 0.0.7

package/components/mikrojs/platform_esp32.cpp

@@ -0,0 +1,192 @@
+#include "mikrojs/platform.h"
+#include "mikrojs_esp32.h"
+
+#include <esp_log.h>
+#include <esp_heap_caps.h>
+#include <esp_mac.h>
+#include <esp_random.h>
+#include <esp_system.h>
+#include <esp_rtc_time.h>
+#include <esp_timer.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/task.h>
+#include <soc/soc_caps.h>
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <unistd.h>
+
+/* Check for LittleFS availability (optional — only used for .df directive) */
+#ifdef CONFIG_LITTLEFS_MAX_PARTITIONS
+#include <esp_littlefs.h>
+#define HAS_LITTLEFS 1
+#else
+#define HAS_LITTLEFS 0
+#endif
+
+static int64_t esp32_get_boot_us(void) {
+    return esp_timer_get_time();
+}
+
+static int64_t esp32_get_rtc_us(void) {
+    return (int64_t)esp_rtc_get_time_us();
+}
+
+static uint32_t esp32_random(void) {
+    return esp_random();
+}
+
+static void esp32_restart(void) {
+    esp_restart();
+}
+
+static void esp32_yield(void) {
+    vTaskDelay(1);
+}
+
+static size_t esp32_get_free_system_mem(void) {
+    return esp_get_free_heap_size();
+}
+
+static size_t esp32_get_min_free_system_mem(void) {
+    return esp_get_minimum_free_heap_size();
+}
+
+static size_t esp32_get_total_system_mem(void) {
+    multi_heap_info_t info;
+    heap_caps_get_info(&info, MALLOC_CAP_8BIT);
+    return info.total_free_bytes + info.total_allocated_bytes;
+}
+
+static size_t esp32_get_largest_free_system_mem(void) {
+    return heap_caps_get_largest_free_block(MALLOC_CAP_8BIT);
+}
+
+static bool esp32_get_fs_info(const char* label, size_t* total, size_t* used) {
+#if HAS_LITTLEFS
+    return esp_littlefs_info(label, total, used) == ESP_OK;
+#else
+    (void)label;
+    (void)total;
+    (void)used;
+    return false;
+#endif
+}
+
+/* JS stdio (console.log / console.error / REPL input) goes through
+ * the same auto-detecting USB-Serial/JTAG + UART0 console that
+ * mik_serial_io.cpp manages. Bypasses newlib stdio / VFS so early
+ * boot doesn't pull in the USB-JTAG VFS on battery-boot-fragile
+ * boards. mik__console_write already handles the "no host attached"
+ * case for USB-JTAG by dropping the payload silently. */
+
+static int esp32_stdout_write(const void* buf, size_t len) {
+    return mik__console_write(buf, len);
+}
+
+static int esp32_stderr_write(const void* buf, size_t len) {
+    return mik__console_write(buf, len);
+}
+
+static int esp32_stdin_read(void* buf, size_t len) {
+    return mik__console_read(buf, len);
+}
+
+/* Base MAC (6 bytes) encoded as Crockford's Base32 (10 lowercase chars).
+ * Lossless: decode the 10 chars to recover the original 6 MAC bytes.
+ * Crockford's Base32 excludes I, L, O, U to avoid visual ambiguity. */
+static const char* esp32_get_device_id(void) {
+    static const char cb32[] = "0123456789abcdefghjkmnpqrstvwxyz";
+    static char id[11] = {0};  /* 6 bytes (48 bits) -> 10 x 5-bit chars + NUL */
+    if (id[0] == '\0') {
+        uint8_t m[6];
+        esp_efuse_mac_get_default(m);
+        /* Pack 6 bytes into a 48-bit value, then extract 5 bits at a time
+         * from the most significant end. */
+        uint64_t v = ((uint64_t)m[0] << 40) | ((uint64_t)m[1] << 32) |
+                     ((uint64_t)m[2] << 24) | ((uint64_t)m[3] << 16) |
+                     ((uint64_t)m[4] << 8) | (uint64_t)m[5];
+        for (int i = 9; i >= 0; i--) {
+            id[i] = cb32[v & 0x1f];
+            v >>= 5;
+        }
+    }
+    return id;
+}
+
+static void esp32_log(int level, const char* tag, const char* fmt, ...) {
+    /* Map MIK_LOG_xxx to ESP_LOG_xxx for the runtime filter check. */
+    esp_log_level_t esp_level;
+    switch (level) {
+        case MIK_LOG_ERROR:
+            esp_level = ESP_LOG_ERROR;
+            break;
+        case MIK_LOG_WARN:
+            esp_level = ESP_LOG_WARN;
+            break;
+        case MIK_LOG_INFO:
+            esp_level = ESP_LOG_INFO;
+            break;
+        case MIK_LOG_DEBUG:
+            esp_level = ESP_LOG_DEBUG;
+            break;
+        case MIK_LOG_VERBOSE:
+            esp_level = ESP_LOG_VERBOSE;
+            break;
+        default:
+            return;
+    }
+
+    /* Apply the same runtime tag filter esp_log_writev would. We can't
+     * delegate to esp_log_writev directly because it passes fmt straight
+     * to vprintf without a prefix or newline, and we want a cross-platform
+     * `[LEVEL] tag: ...` shape that's visually distinct from ESP-IDF's
+     * own `D (12345) tag: ...` subsystem logs. */
+    esp_log_level_t tag_level = esp_log_level_get(tag);
+    if (tag_level == ESP_LOG_NONE || esp_level > tag_level) return;
+
+    printf("[%s] %s: ", mik_log_level_name(level), tag);
+    va_list args;
+    va_start(args, fmt);
+    vprintf(fmt, args);
+    va_end(args);
+    putchar('\n');
+}
+
+static const MIKPlatform esp32_platform = {
+    .get_boot_us = esp32_get_boot_us,
+    .get_rtc_us = esp32_get_rtc_us,
+    .random = esp32_random,
+    .restart = esp32_restart,
+    .yield = esp32_yield,
+    .get_free_system_mem = esp32_get_free_system_mem,
+    .get_min_free_system_mem = esp32_get_min_free_system_mem,
+    .get_total_system_mem = esp32_get_total_system_mem,
+    .get_largest_free_system_mem = esp32_get_largest_free_system_mem,
+    .get_fs_info = esp32_get_fs_info,
+    .log = esp32_log,
+    .stdout_write = esp32_stdout_write,
+    .stderr_write = esp32_stderr_write,
+    .stdin_read = esp32_stdin_read,
+    .get_device_id = esp32_get_device_id,
+};
+
+/*
+ * Global platform pointer + API (replaces platform_posix.cpp for ESP32 builds).
+ * The ESP32 platform is the default, so MIK_SetPlatform() doesn't need to be
+ * called explicitly unless overriding.
+ */
+static const MIKPlatform* current_platform = &esp32_platform;
+
+void MIK_SetPlatform(const MIKPlatform* platform) {
+    current_platform = platform;
+}
+
+const MIKPlatform* MIK_GetPlatform(void) {
+    return current_platform;
+}
+
+const MIKPlatform* MIK_DefaultPOSIXPlatform(void) {
+    /* Not available on ESP32 — return the ESP32 platform instead */
+    return &esp32_platform;
+}

package/components/mikrojs/test/CMakeLists.txt

@@ -0,0 +1,32 @@
+# ble_test.cpp references mik__ble_consume which is only defined when
+# NimBLE (CONFIG_BT_ENABLED) is available. Exclude it for BT-less builds.
+set(_MIK_TEST_SRCS
+    abort_test.cpp
+    fs_js_test.cpp
+    fs_pub_test.cpp
+    http_test.cpp
+    i2c_test.cpp
+    modules_extended_test.cpp
+    modules_test.cpp
+    pins_test.cpp
+    pwm_test.cpp
+    repl_protocol_test.cpp
+    rtc_test.cpp
+    runtime_test.cpp
+    sleep_test.cpp
+    sntp_test.cpp
+    stdio_test.cpp
+    sys_test.cpp
+    text_encoding_test.cpp
+    timers_js_test.cpp
+    timers_test.cpp
+    wifi_test.cpp
+)
+if(CONFIG_BT_ENABLED)
+    list(APPEND _MIK_TEST_SRCS ble_test.cpp)
+endif()
+
+idf_component_register(SRCS ${_MIK_TEST_SRCS}
+        INCLUDE_DIRS "."
+        REQUIRES unity mikrojs spi_flash
+)

package/components/mikrojs/test/abort_test.cpp

@@ -0,0 +1,254 @@
+#include "mikrojs.h"
+#include "quickjs.h"
+#include "unity.h"
+
+static MIKRuntime* rt;
+static JSContext* ctx;
+
+static void setup() {
+    rt = MIK_NewRuntime();
+    ctx = MIK_GetJSContext(rt);
+}
+
+static void teardown() { MIK_FreeRuntime(rt); }
+
+static JSValue eval(const char* code) {
+    return JS_Eval(ctx, code, strlen(code), "test.js", JS_EVAL_TYPE_GLOBAL);
+}
+
+static const char* eval_str(const char* code) {
+    JSValue val = eval(code);
+    const char* s = JS_ToCString(ctx, val);
+    JS_FreeValue(ctx, val);
+    return s;
+}
+
+/* ── AbortController/AbortSignal API tests ───────────────────────── */
+
+TEST_CASE("AbortController is defined as a function", "[abort]") {
+    setup();
+    const char* s = eval_str("typeof AbortController");
+    TEST_ASSERT_EQUAL_STRING("function", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortSignal is defined as a function", "[abort]") {
+    setup();
+    const char* s = eval_str("typeof AbortSignal");
+    TEST_ASSERT_EQUAL_STRING("function", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortError is defined as a function", "[abort]") {
+    setup();
+    const char* s = eval_str("typeof AbortError");
+    TEST_ASSERT_EQUAL_STRING("function", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("TimeoutError is defined as a function", "[abort]") {
+    setup();
+    const char* s = eval_str("typeof TimeoutError");
+    TEST_ASSERT_EQUAL_STRING("function", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortController.signal starts not aborted", "[abort]") {
+    setup();
+    const char* s = eval_str("new AbortController().signal.aborted ? 'yes' : 'no'");
+    TEST_ASSERT_EQUAL_STRING("no", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortController.abort() sets aborted to true", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        const ac = new AbortController();
+        ac.abort();
+        ac.signal.aborted ? 'yes' : 'no';
+    )");
+    TEST_ASSERT_EQUAL_STRING("yes", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortController.abort() sets custom reason", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        const ac = new AbortController();
+        ac.abort("custom reason");
+        ac.signal.reason;
+    )");
+    TEST_ASSERT_EQUAL_STRING("custom reason", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortController.abort() default reason is AbortError", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        const ac = new AbortController();
+        ac.abort();
+        const r = ac.signal.reason;
+        (r instanceof AbortError && r.name === "AbortError") ? "ok" : "fail";
+    )");
+    TEST_ASSERT_EQUAL_STRING("ok", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortSignal.abort() returns pre-aborted signal", "[abort]") {
+    setup();
+    const char* s = eval_str("AbortSignal.abort().aborted ? 'yes' : 'no'");
+    TEST_ASSERT_EQUAL_STRING("yes", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortSignal.throwIfAborted() throws when aborted", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        try {
+            AbortSignal.abort("boom").throwIfAborted();
+            "no throw";
+        } catch (e) { String(e); }
+    )");
+    TEST_ASSERT_EQUAL_STRING("boom", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortSignal.throwIfAborted() is no-op when not aborted", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        try {
+            new AbortController().signal.throwIfAborted();
+            "ok";
+        } catch (e) { "threw"; }
+    )");
+    TEST_ASSERT_EQUAL_STRING("ok", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("abort fires onabort and addEventListener listeners", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        const ac = new AbortController();
+        const called = [];
+        ac.signal.onabort = () => called.push("onabort");
+        ac.signal.addEventListener("abort", () => called.push("listener"));
+        ac.abort();
+        called.join(",");
+    )");
+    TEST_ASSERT_EQUAL_STRING("onabort,listener", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("abort is idempotent - listeners fire only once", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        const ac = new AbortController();
+        let count = 0;
+        ac.signal.addEventListener("abort", () => count++);
+        ac.abort();
+        ac.abort();
+        String(count);
+    )");
+    TEST_ASSERT_EQUAL_STRING("1", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("removeEventListener removes listener", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        const ac = new AbortController();
+        let called = false;
+        const fn = () => { called = true; };
+        ac.signal.addEventListener("abort", fn);
+        ac.signal.removeEventListener("abort", fn);
+        ac.abort();
+        called ? "called" : "not called";
+    )");
+    TEST_ASSERT_EQUAL_STRING("not called", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortSignal.any() aborts when any input aborts", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        const ac1 = new AbortController();
+        const ac2 = new AbortController();
+        const combined = AbortSignal.any([ac1.signal, ac2.signal]);
+        ac2.abort("second");
+        combined.aborted && combined.reason === "second" ? "ok" : "fail";
+    )");
+    TEST_ASSERT_EQUAL_STRING("ok", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortSignal.any() picks up already-aborted signal", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        const aborted = AbortSignal.abort("already");
+        const combined = AbortSignal.any([aborted, new AbortController().signal]);
+        combined.aborted && combined.reason === "already" ? "ok" : "fail";
+    )");
+    TEST_ASSERT_EQUAL_STRING("ok", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortSignal.timeout() creates a signal with TimeoutError name", "[abort]") {
+    setup();
+    // We can't easily test the actual timeout firing (needs event loop),
+    // but we can verify the signal is created and starts non-aborted.
+    const char* s = eval_str(R"(
+        const sig = AbortSignal.timeout(60000);
+        sig instanceof AbortSignal && !sig.aborted ? "ok" : "fail";
+    )");
+    TEST_ASSERT_EQUAL_STRING("ok", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortError has correct name and message", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        const e = new AbortError("test msg");
+        e.name + ":" + e.message;
+    )");
+    TEST_ASSERT_EQUAL_STRING("AbortError:test msg", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("AbortError is an instance of Error", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        new AbortError() instanceof Error ? "yes" : "no";
+    )");
+    TEST_ASSERT_EQUAL_STRING("yes", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}
+
+TEST_CASE("TimeoutError has correct name and message", "[abort]") {
+    setup();
+    const char* s = eval_str(R"(
+        const e = new TimeoutError("test msg");
+        e.name + ":" + e.message;
+    )");
+    TEST_ASSERT_EQUAL_STRING("TimeoutError:test msg", s);
+    JS_FreeCString(ctx, s);
+    teardown();
+}