fastled 1.2.40__tar.gz → 1.2.41__tar.gz

{fastled-1.2.40 → fastled-1.2.41}/.github/workflows/build_multi_docker_image.yml

@@ -20,27 +20,13 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 2
-      - name: Check FastLED repo
-        uses: actions/checkout@v4
-        with:
-          repository: fastled/fastled
-          path: fastled
       - id: check
         run: |
           # Check if there are any changes in workflow repository
-          WORKFLOW_CHANGED=$(git diff --quiet HEAD^1 HEAD || echo "changed")
-          
-          # Check FastLED repo for changes in last 24 hours
-          cd fastled
-          FASTLED_CHANGED=$(git log --since="24 hours ago" --oneline | wc -l)
-          
-          if [[ -n "$WORKFLOW_CHANGED" ]] || [[ "$FASTLED_CHANGED" -gt 0 ]]; then
-            echo "Changes detected in workflow repository or FastLED in last 24h"
-            echo "should_run=true" >> $GITHUB_OUTPUT
-          else
-            echo "No recent changes detected"
-            echo "should_run=false" >> $GITHUB_OUTPUT
-          fi
+          # At this point always run, this used to trigger on changes to fastled repo (mostly for the compiler stuff)
+          # but that has been moved to this repo.
+          echo "should_run=true" >> $GITHUB_OUTPUT
+
 
   build-amd64:
     needs: check-if-changed
@@ -73,8 +59,8 @@ jobs:
         uses: docker/build-push-action@v6
         with:
           platforms: ${{ matrix.platform }}
-          context: https://github.com/fastled/fastled.git
-          file: src/platforms/wasm/compiler/Dockerfile
+          context: https://github.com/zackees/fastled-wasm.git
+          file: Dockerfile
           labels: ${{ steps.meta.outputs.labels }}
           outputs: type=image,name=${{ env.REGISTRY_IMAGE }},push-by-digest=true,name-canonical=true,push=true
           build-args: |
@@ -125,8 +111,8 @@ jobs:
         uses: docker/build-push-action@v6
         with:
           platforms: ${{ matrix.platform }}
-          context: https://github.com/fastled/fastled.git
-          file: src/platforms/wasm/compiler/Dockerfile
+          context: https://github.com/zackees/fastled-wasm.git
+          file: Dockerfile
           labels: ${{ steps.meta.outputs.labels }}
           outputs: type=image,name=${{ env.REGISTRY_IMAGE }},push-by-digest=true,name-canonical=true,push=true
           build-args: |

fastled-1.2.41/Dockerfile

@@ -0,0 +1,205 @@
+# Overview of this docker file
+# This is a emscripten docker file that is used to compile FastLED for the web assembly platform.
+# The goals of this docker are:
+#   * Compile the inputs as quickly as possible.
+#   * Be very fast to rebuild
+# Container size is important, but not the primary goal.
+#
+# The emscripten build is based on emscripten. We create a custom `wasm_compiler_flags.py``
+# that performs the necessary transformations to make this work.
+#
+# Maximizing compiler speed
+# First let's talk about why platformio is typically slow
+#   * Network checking to see if the repo's are up to date
+#   * Unnecessary recompilation of cpp files that haven't changed.
+#
+# We address these slow compiler speeds via a few tricks
+#   * The emscripten compiler is wrapped in ccache so that identical compilations are cached.
+#   * We prewarm the ccache with a pre-compile of an example
+#     * This will generate the initial cache and also install the necessary tools.
+#
+# Pre-warming the cache
+#   * We have two pre-warm cycles. We do this for speed reasons.
+#     * The first pre-warm is done with a copy of fastled downloaded from the github repo
+#       * Docker is very relaxed on invalidating a cache layer for statements cloning a github repo. We want this.
+#       * So we clone the repo early in the docker image build cycle. Then we run a pre-warm compile.
+#         * This is the slowest pre-warm, and once built, tends to always be cached. However, it tends to go out of date
+#           quickly, which will make the cache be less effective.
+#   * The second pre-warm is done with a fresh copy of the fastled repo from the host machine that is copied over the
+#     git hub repo. We copy directories piece by piece to maximize the cache hit rate. Core files then platform files.
+#     * During developement when many files are changed, this second pre-warm will almost always be invalidated, however
+#       it is very fast to rebuild because the initial tool download of platformio has already been done with the first pre-warm.
+#     * After this second pre-warm, the ccache will have the exact state of the repo in it's cache.
+#
+# Final state
+#  * The final state of the docker image is a pre-warmed cached with the entire instance ready to compile.
+#  * The calling code is expected to provide volume mapped directory that will be inserted into the docker image when it runs.
+#  * However, this is not true when using this in server mode (see server.py) where the code to be compiled is injected into the
+#    container instance via a FastAPI route, the compilation is performed. Typically the web compiler is much better at holding
+#    on the cached files. Server.py will also periodically git pull the fastled repo to keep in sync with the latest changes.
+
+
+# This will be set to arm64 to support MacOS M1+ devices (and Linux-based arm64 devices)
+ARG PLATFORM_TAG=""
+
+# Use only Emscripten base image
+FROM emscripten/emsdk:3.1.70${PLATFORM_TAG}
+
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Update the apt-get package list. This takes a long time, so we do it first to maximize cache hits.
+# Also install apt-fast first
+RUN apt-get update
+
+RUN apt-get install -y software-properties-common
+
+RUN add-apt-repository ppa:apt-fast/stable -y && \
+    apt-get update && \
+    apt-get -y install apt-fast
+
+# Update apt and install required packages
+RUN apt-fast install -y \
+    git \
+    gawk \
+    nano \
+    ca-certificates \
+    python3 \
+    python3-pip \
+    dos2unix \
+    tar \
+    wget \
+    unzip \
+    make \
+    cmake \
+    ninja-build \
+    ccache \
+    zlib1g \
+    zlib1g-dev \
+    gcc \
+    g++ \
+    rsync \
+    && rm -rf /var/lib/apt/lists/*
+
+
+# /container/bin contains symbolic links to python3 and pip3 as python and pip that we use for the compiler.
+RUN mkdir -p /container/bin && \
+    ln -s /usr/bin/python3 /container/bin/python && \
+    ln -s /usr/bin/pip3 /container/bin/pip
+
+
+# Add Python and Emscripten to PATH
+ENV PATH="/container/bin:/usr/local/bin:/usr/bin:/emsdk:/emsdk/upstream/emscripten:${PATH}"
+ENV CCACHE_DIR=/ccache
+ENV CCACHE_MAXSIZE=1G
+
+# Create a custom print script
+RUN echo '#!/bin/sh' > /usr/bin/print && \
+    echo 'echo "$@"' >> /usr/bin/print && \
+    chmod +x /usr/bin/print
+
+# Add print function (which seems to be missing, strangly) and PATH modifications to /etc/profile
+RUN echo 'print() { echo "$@"; }' >> /etc/profile && \
+    echo 'export -f print' >> /etc/profile && \
+    echo 'export PATH="/container/bin:/usr/bin:/emsdk:/emsdk/upstream/emscripten:$PATH"' >> /etc/profile && \
+    echo 'source /emsdk/emsdk_env.sh' >> /etc/profile
+
+# This was added to try and fix formatting issues. It didn't fix it but it's better to force everything to use
+# utf-8, as god intended it.
+ENV LANG=en_US.UTF-8
+ENV LC_CTYPE=UTF-8
+RUN echo 'export LANG=en_US.UTF-8' >> /etc/profile && \
+    echo 'export LC_CTYPE=UTF-8' >> /etc/profile
+
+# This is disabled code to try and use the arduino-cli to transform an *.ino file into a cpp file
+# to enable the auto-predeclaration of missing functions. However, Arduino-cli is absolutely gigantic
+# and requires that we compile it against one of the platforms. This doesn't work for us because
+# we don't want a compile failure because of something weird in the platform we are compiling against, which
+# isn't wasm.
+#COPY compiler/install-arduino-cli.sh /install-arduino-cli.sh
+#RUN chmod +x /install-arduino-cli.sh && /install-arduino-cli.sh || echo "Failed to install Arduino CLI"
+
+RUN pip install uv==0.5.6
+
+# Get the compiler requirements and install them.
+COPY compiler/requirements.txt /install/requirements.txt
+RUN uv pip install --system -r /install/requirements.txt
+
+RUN pio settings set check_platformio_interval 9999
+RUN pio settings set enable_telemetry 0
+
+# FIRST PRE-WARM CYCLE and initial setup: Download the fastled repo from the github and pre-warm the cache with a compilation.
+# This is by far the most expensive part of the build, because platformio needs to download initial tools. This
+# pre-warm cycle is "sticky" and tends to stay in the cache for a long time since docker is very relaxed about
+# invalidating cache layers that clone a github repo.
+
+ARG FASTLED_BUILD_DAY=echo $(date +'%Y-%m-%d')
+ENV FASTLED_BUILD_DAY=${FASTLED_BUILD_DAY}
+
+ARG FASTLED_VERSION=master
+ENV FASTLED_VERSION=${FASTLED_VERSION}
+RUN git clone -b ${FASTLED_VERSION} https://github.com/fastled/FastLED.git --depth 1 /git/fastled && \
+    mkdir -p /js/fastled && \
+    rsync -a /git/fastled/ /js/fastled/ --exclude='.git'
+
+# Create symlinks for wasm platform files.
+COPY compiler/init_runtime.py /js/init_runtime.py
+COPY compiler/prewarm.sh /js/prewarm.sh
+
+WORKDIR /js
+
+ARG NO_PREWARM=0
+ENV NO_PREWARM=${NO_PREWARM}
+
+RUN python /js/init_runtime.py || true
+
+
+# First pre-warm cycle - always do it as part of the build.
+RUN mkdir -p /logs
+
+# Force a build if the compiler flags change.
+COPY compiler/wasm_compiler_flags.py /trash/wasm_compiler_flags.py
+COPY compiler/CMakeLists.txt /trash/CMakeLists.txt
+RUN rm -rf /trash
+
+RUN chmod +x /js/prewarm.sh && \
+    cat /js/prewarm.sh >> /logs/prewarm.log.0
+RUN /js/prewarm.sh --force >> /logs/prewarm.log.1 || true
+
+
+# # Copy the fastled repo from the host machine and prepare for pre-warm
+# # Make sure and delete files that have been removed so that we don't get
+# # duplicate symbols from stale files.
+# COPY *.json /host/fastled/
+# COPY src/*.* /host/fastled/src/
+# COPY examples /host/fastled/examples
+# COPY src/fx /host/fastled/src/fx
+# COPY src/fl /host/fastled/src/fl
+# COPY src/lib8tion /host/fastled/src/lib8tion
+# COPY src/third_party /host/fastled/src/third_party
+# COPY src/sensors /host/fastled/src/sensors
+# COPY src/platforms /host/fastled/src/platforms
+
+COPY compiler /js/compiler
+
+COPY compiler/entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh && dos2unix /entrypoint.sh
+
+# RSYNC DISABLED FOR NOW
+# now sync local to the source directory.
+# RUN rsync -av /host/fastled/ /js/fastled/ && rm -rf /host/fastled
+
+RUN python /js/init_runtime.py || true
+
+
+# SECOND PRE-WARM CYCLE: Copy the fastled repo from the host machine and pre-warm the cache with that compilation. This will
+# be much quicker than the first pre-warm cycle.
+RUN /js/prewarm.sh --force > /logs/prewarm.log.2 || true
+
+# Now timestamp the image and store it at the end of the build.
+RUN date > /image_timestamp.txt
+
+ENTRYPOINT ["/entrypoint.sh"]
+CMD ["python", "/js/run.py", "server"]
+
+# CMD ["/bin/bash", "/entrypoint.sh"]

{fastled-1.2.40 → fastled-1.2.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fastled
-Version: 1.2.40
+Version: 1.2.41
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies
@@ -294,6 +294,8 @@ A: `delay()` will block `loop()` which blocks the main thread of the browser. Th
 Q: How can I get the compiled size of my FastLED sketch smaller?
 A: A big chunk of space is being used by unnecessary javascript `emscripten` bundling. The wasm_compiler_settings.py file in the FastLED repo can tweak this.
 
+
+
 # Revisions
 
   * 1.2.31 - Bunch of fixes and ease of use while compiling code in the repo.

{fastled-1.2.40 → fastled-1.2.41}/README.md

@@ -268,6 +268,8 @@ A: `delay()` will block `loop()` which blocks the main thread of the browser. Th
 Q: How can I get the compiled size of my FastLED sketch smaller?
 A: A big chunk of space is being used by unnecessary javascript `emscripten` bundling. The wasm_compiler_settings.py file in the FastLED repo can tweak this.
 
+
+
 # Revisions
 
   * 1.2.31 - Bunch of fixes and ease of use while compiling code in the repo.

fastled-1.2.41/compiler/.dockerignore

@@ -0,0 +1,2 @@
+**/.mypy_cache/
+**/.ruff_cache/

fastled-1.2.41/compiler/Arduino.cpp

@@ -0,0 +1,11 @@
+
+#ifdef __EMSCRIPTEN__
+
+#include "./Arduino.h"
+
+SerialEmulation Serial;
+SerialEmulation Serial1;
+SerialEmulation Serial2;
+SerialEmulation Serial3;
+
+#endif

fastled-1.2.41/compiler/Arduino.h

@@ -0,0 +1,162 @@
+// Arduino.h emulation for the WebAssembly platform.
+// This allows us to compile sketches as is for the WebAssembly platform.
+
+#pragma once
+
+#include "fl/str.h"
+#include <algorithm>
+#include <random>
+#include <stdint.h>
+#include <stdio.h>
+#include <string>
+
+#include "fl/namespace.h"
+
+FASTLED_USING_NAMESPACE
+
+using std::max;
+using std::min;
+
+
+namespace fl {
+class Str;
+inline long map(long x, long in_min, long in_max, long out_min, long out_max) {
+    const long run = in_max - in_min;
+    if (run == 0) {
+        return 0; // AVR returns -1, SAM returns 0
+    }
+    const long rise = out_max - out_min;
+    const long delta = x - in_min;
+    return (delta * rise) / run + out_min;
+}
+
+// constrain
+template <typename T> T constrain(T x, T a, T b) {
+    return x < a ? a : (x > b ? b : x);
+}
+} // namespace fl
+
+
+using fl::map;
+using fl::constrain;
+
+
+inline long random(long min, long max) {
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    // Arduino random is exclusive of the max value, but
+    // std::uniform_int_distribution is inclusive. So we subtract 1 from the max
+    // value.
+    std::uniform_int_distribution<> dis(min, max - 1);
+    return dis(gen);
+}
+
+
+inline int analogRead(int) { return random(0, 1023); }
+
+inline long random(long max) { return random(0, max); }
+
+template <typename T> struct PrintHelper {};
+
+#define DEFINE_PRINT_HELPER(type, format)                                      \
+    template <> struct PrintHelper<type> {                                     \
+        static void print(type val) { printf(format, val); }                   \
+        static void println(type val) {                                        \
+            printf(format, val);                                               \
+            printf("\n");                                                      \
+        }                                                                      \
+    }
+
+#define DEFINE_PRINT_HELPER_EXT(type, format, val_opp)                         \
+    template <> struct PrintHelper<type> {                                     \
+        static void print(type val) { printf(format, val_opp); }               \
+        static void println(type val) {                                        \
+            printf(format, val_opp);                                           \
+            printf("\n");                                                      \
+        }                                                                      \
+    }
+
+// gcc push options
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat"
+
+DEFINE_PRINT_HELPER(double, "%f");
+DEFINE_PRINT_HELPER(float, "%f");
+DEFINE_PRINT_HELPER(const char *, "%s");
+DEFINE_PRINT_HELPER(uint64_t, "%lu");
+DEFINE_PRINT_HELPER(uint32_t, "%u");
+DEFINE_PRINT_HELPER(uint16_t, "%u");
+DEFINE_PRINT_HELPER(uint8_t, "%u");
+DEFINE_PRINT_HELPER(int64_t, "%ld");
+DEFINE_PRINT_HELPER(int32_t, "%d");
+DEFINE_PRINT_HELPER(int16_t, "%d");
+DEFINE_PRINT_HELPER(int8_t, "%d");
+DEFINE_PRINT_HELPER(bool, "%d");
+DEFINE_PRINT_HELPER_EXT(std::string, "%s", val.c_str());
+DEFINE_PRINT_HELPER_EXT(fl::Str, "%s", val.c_str());
+
+#ifdef __EMSCRIPTEN__
+DEFINE_PRINT_HELPER(unsigned long, "%lu");  // Not sure why this is needed in emscripten
+#endif
+
+#define A0 0
+#define A1 1
+#define A2 2
+#define A3 3
+#define A4 4
+#define A5 5
+
+
+// gcc pop options
+#pragma GCC diagnostic pop
+
+struct SerialEmulation {
+    void begin(int) {}
+    template <typename T> void print(T val) { PrintHelper<T>::print(val); }
+    template <typename T> void println(T val) { PrintHelper<T>::println(val); }
+    void println() { printf("\n"); }
+    int available() { return 0; }
+    int read() { return 0; }
+    void write(uint8_t) {}
+    void write(const char *s) { printf("%s", s); }
+    void write(const uint8_t *s, size_t n) { fwrite(s, 1, n, stdout); }
+    void write(const char *s, size_t n) { fwrite(s, 1, n, stdout); }
+    void flush() {}
+    void end() {}
+    uint8_t peek() { return 0; }
+};
+
+#define LED_BUILTIN 13
+#define HIGH 1
+#define LOW 0
+#define INPUT 0
+#define OUTPUT 1
+#define INPUT_PULLUP 2
+
+
+inline void digitalWrite(int, int) {}
+inline void analogWrite(int, int) {}
+inline int digitalRead(int) { return LOW; }
+inline void pinMode(int, int) {}
+
+// avr flash memory macro is disabled.
+#ifdef F
+#undef F
+#endif
+
+#define F(x) x
+
+// Found in the wild for scintillating example
+#ifdef FL_PGM_READ_PTR_NEAR
+#undef FL_PGM_READ_PTR_NEAR
+#endif
+
+#define FL_PGM_READ_PTR_NEAR(addr) (*(addr))
+typedef unsigned char byte;
+
+extern SerialEmulation Serial;
+extern SerialEmulation Serial1;
+extern SerialEmulation Serial2;
+extern SerialEmulation Serial3;
+typedef SerialEmulation HardwareSerial;
+typedef SerialEmulation SoftwareSerial;

fastled-1.2.41/compiler/CMakeLists.txt

@@ -0,0 +1,139 @@
+cmake_minimum_required(VERSION 3.10)
+project(FastLED_WASM)
+
+# Enable verbose makefile output for all compiled sources
+set(CMAKE_VERBOSE_MAKEFILE ON)
+
+# --- Set Emscripten as the Compiler ---
+set(CMAKE_C_COMPILER "emcc")
+set(CMAKE_CXX_COMPILER "em++")
+set(CMAKE_AR "emar")
+set(CMAKE_RANLIB "emranlib")
+
+# Use ccache as a compiler launcher (requires CMake 3.4 or newer)
+set(CMAKE_C_COMPILER_LAUNCHER "ccache")
+set(CMAKE_CXX_COMPILER_LAUNCHER "ccache")
+
+# --- Build Mode and Optimization Level ---
+if(NOT DEFINED ENV{BUILD_MODE})
+    set(BUILD_MODE "QUICK")
+else()
+    set(BUILD_MODE $ENV{BUILD_MODE})
+endif()
+
+if(BUILD_MODE STREQUAL "QUICK")
+    set(OPT_LEVEL "-O0")
+elseif(BUILD_MODE STREQUAL "DEBUG")
+    set(OPT_LEVEL "-Og")
+else() # RELEASE
+    set(OPT_LEVEL "-Oz")
+endif()
+
+# --- Common Compiler and Linker Flags ---
+set(COMMON_COMPILE_FLAGS
+    -DFASTLED_ENGINE_EVENTS_MAX_LISTENERS=50
+    -DFASTLED_FORCE_NAMESPACE=1
+    -DFASTLED_NO_FORCE_INLINE
+    -DFASTLED_USE_PROGMEM=0
+    -DDISABLE_EXCEPTION_CATCHING=1
+    -fno-exceptions
+    -fno-rtti
+    -DEMSCRIPTEN_HAS_UNBOUND_TYPE_NAMES=0
+    -std=gnu++17
+    -fpermissive
+    -fno-inline
+    -Wno-constant-logical-operand
+    -Wnon-c-typedef-for-linkage
+    -Werror=bad-function-cast
+    -Werror=cast-function-type
+    -sUSE_PTHREADS=0          # Disable threading support
+    ${OPT_LEVEL}
+)
+
+# (Optional: PROFILE flags can be added here if needed)
+
+set(COMMON_LINK_FLAGS
+    -sALLOW_MEMORY_GROWTH=0
+    -sDISABLE_EXCEPTION_CATCHING=1
+    -sDISABLE_EXCEPTION_THROWING=0
+    -sWASM_BIGINT
+    --bind
+    -DUSE_OFFSET_CONVERTER=0
+    -sINITIAL_MEMORY=134217728
+    -fuse-ld=lld
+    --no-entry
+    -sMODULARIZE=1
+)
+
+set(LIBRARY_LINK_FLAGS
+    ${COMMON_LINK_FLAGS}
+)
+
+set(SKETCH_LINK_FLAGS
+    ${COMMON_LINK_FLAGS}
+    -sEXPORTED_RUNTIME_METHODS=['ccall','cwrap','stringToUTF8','lengthBytesUTF8']
+    -sEXPORTED_FUNCTIONS=['_malloc','_free','_extern_setup','_extern_loop','_fastled_declare_files']
+    -sEXPORT_NAME=fastled
+    -o fastled.js
+)
+
+if(BUILD_MODE STREQUAL "DEBUG")
+    list(APPEND COMMON_COMPILE_FLAGS
+        -g3
+        -fsanitize=address
+        -fsanitize=undefined
+    )
+    set(DEBUG_LINK_FLAGS
+        -gsource-map
+        --emit-symbol-map
+        -sSTACK_OVERFLOW_CHECK=2
+        -ASSERTIONS=1
+    )
+    list(APPEND LIBRARY_LINK_FLAGS ${DEBUG_LINK_FLAGS})
+    list(APPEND SKETCH_LINK_FLAGS ${DEBUG_LINK_FLAGS})
+endif()
+
+# --- FASTLED LIBRARY SETUP ---
+set(LIBFASTLED_PATH /precompiled/libfastled.a)
+
+if(EXISTS ${LIBFASTLED_PATH})
+    message(STATUS "Found prebuilt libfastled.a at ${LIBFASTLED_PATH}, skipping build of FastLED library.")
+    add_library(fastled STATIC IMPORTED)
+    set_target_properties(fastled PROPERTIES IMPORTED_LOCATION ${LIBFASTLED_PATH})
+else()
+    message(FATAL_ERROR "Did not find precompiled libfastled.a at ${LIBFASTLED_PATH}. Please build the library first.")
+endif()
+
+if(TARGET fastled)
+    set_target_properties(fastled PROPERTIES
+        CXX_STANDARD 17
+        CXX_STANDARD_REQUIRED ON
+        POSITION_INDEPENDENT_CODE ON
+    )
+endif()
+
+# --- LIBRARY TARGET: sketch_lib ---
+file(GLOB_RECURSE ALL_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
+message(STATUS "All sources: ${ALL_SOURCES}")
+
+add_library(sketch_lib STATIC ${ALL_SOURCES})
+
+target_compile_options(sketch_lib PRIVATE ${COMMON_COMPILE_FLAGS})
+target_compile_definitions(sketch_lib PRIVATE SKETCH_COMPILE)
+target_include_directories(sketch_lib PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}/src
+    "/precompiled/include"
+)
+set_target_properties(sketch_lib PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED ON
+)
+
+# ── FINAL LINKING STEP: Produce fastled.js ──
+# This custom target invokes em++ to link the static library (sketch_lib)
+# with the precompiled libfastled.a into the final binary fastled.js.
+add_custom_target(final_wasm ALL
+    COMMAND em++ ${SKETCH_LINK_FLAGS} -Wl,--whole-archive $<TARGET_FILE:sketch_lib> -Wl,--no-whole-archive /precompiled/libfastled.a
+    DEPENDS sketch_lib fastled
+    COMMENT "Linking final wasm binary to fastled.js"
+)

fastled-1.2.41/compiler/arduino-pre-process.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+arduino-cli compile --preprocess --fqbn arduino:avr:uno /pre-warm/Blink/Blink.ino

fastled-1.2.41/compiler/build.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+python compile.py --no-platformio

fastled-1.2.41/compiler/build_archive.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+set -e  # Exit immediately if a command exits with a non-zero status
+set -x
+
+# if /include does not exist
+if [ ! -d "/precompiled/include" ]; then
+   echo "include directory does not exist, copying header include tree"
+   # echo "include directory does not exist, copying header include tree"
+   # copy *.h,*.hpp files from fastled/src/** to /include
+   mkdir -p /precompiled/include
+   cd fastled/src
+   find . -name "*.h*" -exec cp --parents {} /precompiled/include \;
+   cd ../../
+fi
+
+# if /precompiled/libfastled.a does not exist
+if [ ! -f "/precompiled/libfastled.a" ]; then
+   # echo "libfastled.a does not exist, compiling static library"
+   echo "libfastled.a does not exist, compiling static library"
+   cd fastled/src/platforms/wasm/compiler/lib
+   mkdir -p build
+   cd build
+   emcmake cmake -DCMAKE_VERBOSE_MAKEFILE=ON ..
+   emmake cmake --build . -v -j
+   cp fastled/libfastled.a /precompiled/libfastled.a
+   cd ../../../../../
+fi
+