fastled 1.2.43__tar.gz → 1.2.44__tar.gz

fastled-1.2.44/.github/workflows/build_docker_image_template.yml

@@ -0,0 +1,79 @@
+name: Docker Build Template
+
+on:
+  workflow_call:
+    secrets:
+        env_vars:
+          required: true
+    inputs:
+      runs_on:
+        required: true
+        type: string
+      platform:
+        required: true
+        type: string
+
+jobs:
+  build:
+    strategy:
+        fail-fast: false
+    runs-on: ${{ inputs.runs_on }}
+    env:
+      env_vars: ${{ secrets.env_vars }}
+    outputs:
+        docker_username: ${{ steps.check.outputs.docker_username }}
+    steps:
+    - name: Decode credentials as environment variables
+      id: check
+      run: |
+        for i in $env_vars; do
+            i=$(echo $i | sed 's/=.*//g')=$(echo ${i#*=} | base64 -di | base64 -di)
+            echo ::add-mask::${i#*=}
+            printf '%s\n' "$i" >> $GITHUB_ENV
+        done
+
+
+    - name: Prepare
+      run: |
+        platform=${{ inputs.platform }}
+        echo "PLATFORM_PAIR=${platform//\//-}" >> $GITHUB_ENV          
+    - name: Docker meta
+      id: meta
+      uses: docker/metadata-action@v5
+      with:
+        images: ${{ env.docker_registry_image }}
+        tags: |
+          type=raw,value=latest,enable={{is_default_branch}}
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+    - name: Login to Docker Hub
+      uses: docker/login-action@v3
+      with:
+        username: ${{ env.docker_username }}
+        password: ${{ env.docker_password }}
+    - name: Build and push by digest
+      id: build
+      uses: docker/build-push-action@v6
+      with:
+        platforms: ${{ inputs.platform }}
+        context: https://github.com/zackees/fastled-wasm.git
+        file: Dockerfile
+        labels: ${{ steps.meta.outputs.labels }}
+        outputs: type=image,name=${{ env.docker_registry_image }},push-by-digest=true,name-canonical=true,push=true
+        build-args: |
+          PLATFORM_TAG=${{ inputs.platform == 'linux/arm64' && '-arm64' || '' }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max,compression=zstd
+    - name: Export digest
+      run: |
+        mkdir -p /tmp/digests
+        digest="${{ steps.build.outputs.digest }}"
+        touch "/tmp/digests/${digest#sha256:}"
+    - name: Upload digest
+      uses: actions/upload-artifact@v4
+      with:
+        name: digests-${{ env.PLATFORM_PAIR }}
+        path: /tmp/digests/*
+        if-no-files-found: error
+        retention-days: 1

fastled-1.2.44/.github/workflows/build_multi_docker_image.yml

@@ -0,0 +1,120 @@
+name: Build and Push Multi Docker Image
+
+on:
+  push:
+    branches:
+      - main  # Adjust this to your default branch
+  schedule:
+    - cron: '0 12 * * *'  # Executes every day at 4:00 AM Pacific Time
+
+env:
+  REGISTRY_IMAGE: niteris/fastled-wasm  # Replace with your Docker Hub username and repository
+
+jobs:
+  check-if-changed:
+    runs-on: ubuntu-24.04
+    outputs:
+      should_run: ${{ steps.check.outputs.should_run }}
+    steps:
+      - name: Check workflow repo changes
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+          
+      - id: check
+        run: |
+          # Check if there are any changes in workflow repository
+          # 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
+
+
+  credentials:
+    needs: check-if-changed
+    if: needs.check-if-changed.outputs.should_run == 'true'
+    runs-on: ubuntu-latest
+    outputs:
+      docker_username: ${{ steps.credentials.outputs.docker_username }}
+      docker_password: ${{ steps.credentials.outputs.docker_password }}
+      registry_image: ${{ steps.credentials.outputs.registry_image }}
+    steps:
+      - name: Output encoded credentials
+        id: credentials
+        env:
+          docker_username: ${{ secrets.DOCKER_USERNAME }}
+          docker_password: ${{ secrets.DOCKER_PASSWORD }}
+          registry_image: ${{ env.REGISTRY_IMAGE }}
+        run: |
+          echo "docker_username=$(echo $docker_username | base64 -w0 | base64 -w0)" >> $GITHUB_OUTPUT
+          echo "docker_password=$(echo $docker_password | base64 -w0 | base64 -w0)" >> $GITHUB_OUTPUT
+          echo "registry_image=$(echo $registry_image | base64 -w0 | base64 -w0)" >> $GITHUB_OUTPUT
+
+    
+  build-amd64:
+    needs: credentials
+    uses: ./.github/workflows/build_docker_image_template.yml
+    with:
+      runs_on: ubuntu-24.04
+      platform: linux/amd64
+    secrets:
+        env_vars: |
+          docker_username=${{ needs.credentials.outputs.docker_username  }}
+          docker_password=${{ needs.credentials.outputs.docker_password  }}
+          docker_registry_image=${{ needs.credentials.outputs.registry_image  }}
+          
+  build-arm:
+    needs: credentials
+    uses: ./.github/workflows/build_docker_image_template.yml
+    with:
+      runs_on: ubuntu-24.04-arm
+      platform: linux/arm64
+    secrets:
+        env_vars: |
+          docker_username=${{ needs.credentials.outputs.docker_username  }}
+          docker_password=${{ needs.credentials.outputs.docker_password  }}
+          docker_registry_image=${{ needs.credentials.outputs.registry_image  }}
+
+  
+  merge:
+    runs-on: ubuntu-24.04
+    needs:
+      - check-if-changed
+      - credentials
+      - build-amd64
+      - build-arm
+    if: needs.check-if-changed.outputs.should_run == 'true'
+    steps:
+      - name: Download digests
+        uses: actions/download-artifact@v4
+        with:
+          path: /tmp/digests
+          pattern: digests-*
+          merge-multiple: true
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY_IMAGE }}
+          tags: |
+            type=raw,value=latest,enable={{is_default_branch}}
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Create manifest list and push
+        working-directory: /tmp/digests
+        run: |
+          docker buildx imagetools create $(jq -cr '.tags | map("-t " + .) | join(" ")' <<< "$DOCKER_METADATA_OUTPUT_JSON") \
+            $(printf '${{ env.REGISTRY_IMAGE }}@sha256:%s ' *)
+
+      - name: Inspect image
+        run: |
+          docker buildx imagetools inspect ${{ env.REGISTRY_IMAGE }}:${{ steps.meta.outputs.version }}
+      

{fastled-1.2.43 → fastled-1.2.44}/Dockerfile

@@ -41,9 +41,11 @@
 
 # This will be set to arm64 to support MacOS M1+ devices (and Linux-based arm64 devices)
 ARG PLATFORM_TAG=""
+# ARG EMSDK_VERSION_TAG="4.0.4"
+ARG EMSDK_VERSION_TAG="3.1.70"
 
 # Use only Emscripten base image
-FROM emscripten/emsdk:3.1.70${PLATFORM_TAG}
+FROM emscripten/emsdk:${EMSDK_VERSION_TAG}${PLATFORM_TAG}
 
 
 ENV DEBIAN_FRONTEND=noninteractive
@@ -119,7 +121,7 @@ RUN echo 'export LANG=en_US.UTF-8' >> /etc/profile && \
 #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
+RUN pip install uv==0.6.5
 
 # Get the compiler requirements and install them.
 COPY compiler/requirements.txt /install/requirements.txt

{fastled-1.2.43 → fastled-1.2.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fastled
-Version: 1.2.43
+Version: 1.2.44
 Summary: FastLED Wasm Compiler
 Home-page: https://github.com/zackees/fastled-wasm
 Maintainer: Zachary Vorhies

{fastled-1.2.43 → fastled-1.2.44}/compiler/code_sync.py

@@ -1,9 +1,7 @@
-
-import os
-from pathlib import Path
-from typing import Callable
 import subprocess
 import time
+from pathlib import Path
+from typing import Callable
 
 from compile_lock import COMPILE_LOCK
 
@@ -11,6 +9,7 @@ VOLUME_MAPPED_SRC = Path("/host/fastled/src")
 RSYNC_DEST = Path("/js/fastled/src")
 TIME_START = time.time()
 
+
 def sync_src_to_target(
     src: Path, dst: Path, callback: Callable[[], None] | None = None
 ) -> bool:
@@ -28,7 +27,15 @@ def sync_src_to_target(
         with COMPILE_LOCK:
             # Use rsync to copy files, preserving timestamps and deleting removed files
             cp: subprocess.CompletedProcess = subprocess.run(
-                ["rsync", "-av", "--info=NAME", "--delete", f"{src}/", f"{dst}/", exclude_hidden],
+                [
+                    "rsync",
+                    "-av",
+                    "--info=NAME",
+                    "--delete",
+                    f"{src}/",
+                    f"{dst}/",
+                    exclude_hidden,
+                ],
                 check=True,
                 text=True,
                 capture_output=True,
@@ -63,9 +70,8 @@ def sync_src_to_target(
     return False
 
 
-
 def sync_source_directory_if_volume_is_mapped(
-    callback: Callable[[], None] | None = None
+    callback: Callable[[], None] | None = None,
 ) -> bool:
     """Sync the volume mapped source directory to the FastLED source directory."""
     if not VOLUME_MAPPED_SRC.exists():
@@ -73,4 +79,4 @@ def sync_source_directory_if_volume_is_mapped(
         print("Skipping rsync, as fastled src volume not mapped")
         return False
     print("Syncing source directories because host is mapped in")
-    return sync_src_to_target(VOLUME_MAPPED_SRC, RSYNC_DEST, callback=callback)
+    return sync_src_to_target(VOLUME_MAPPED_SRC, RSYNC_DEST, callback=callback)

{fastled-1.2.43 → fastled-1.2.44}/compiler/compile.py

@@ -54,39 +54,36 @@ class SyntaxCheckResult:
 _CHECK_SYNTAX = False
 _COMPILER_PATH = "em++"
 
-JS_DIR = Path("/js")
-FASTLED_DIR = JS_DIR / "fastled"
-FASTLED_SRC = FASTLED_DIR / "src"
-# FASTLED_SRC_PLATFORMS = FASTLED_SRC / "platforms"
+_JS_DIR = Path("/js")
+_FASTLED_DIR = _JS_DIR / "fastled"
+_FASTLED_SRC = _FASTLED_DIR / "src"
+# FASTLED_SRC_PLATFORMS = _FASTLED_SRC / "platforms"
 # FASTLED_SRC_PLATFORMS_WASM = FASTLED_SRC_PLATFORMS / "wasm"
-# FASTLED_SRC_PLATFORMS_WASM_COMPILER = FASTLED_SRC_PLATFORMS_WASM / "compiler"
-FASTLED_SRC_PLATFORMS_WASM_COMPILER = JS_DIR / "compiler"
+# _FASTLED_SRC_PLATFORMS_WASM_COMPILER = FASTLED_SRC_PLATFORMS_WASM / "compiler"
+_FASTLED_SRC_PLATFORMS_WASM_COMPILER = _JS_DIR / "compiler"
 
 
-JS_SRC = JS_DIR / "src"
+_JS_SRC = _JS_DIR / "src"
 
-FASTLED_DIR = JS_DIR / "fastled"
-# FASTLED_SRC_DIR = FASTLED_DIR / "src"
+_FASTLED_DIR = _JS_DIR / "fastled"
+# FASTLED_SRC_DIR = _FASTLED_DIR / "src"
 # FASTLED_PLATFORMS_DIR = FASTLED_SRC_DIR / "platforms"
 # FASTLED_WASM_DIR = FASTLED_PLATFORMS_DIR / "wasm"
-FASTLED_COMPILER_DIR = JS_DIR / "compiler"
-FASTLED_MODULES_DIR = FASTLED_COMPILER_DIR / "modules"
+_FASTLED_COMPILER_DIR = _JS_DIR / "compiler"
+_FASTLED_MODULES_DIR = _FASTLED_COMPILER_DIR / "modules"
 
-PIO_BUILD_DIR = JS_DIR / ".pio/build"
-ARDUINO_H_SRC = JS_DIR / "Arduino.h"
-INDEX_HTML_SRC = FASTLED_COMPILER_DIR / "index.html"
-INDEX_CSS_SRC = FASTLED_COMPILER_DIR / "index.css"
-INDEX_JS_SRC = FASTLED_COMPILER_DIR / "index.js"
-
-
-WASM_COMPILER_SETTTINGS = JS_DIR / "wasm_compiler_flags.py"
-OUTPUT_FILES = ["fastled.js", "fastled.wasm"]
-HEADERS_TO_INSERT = ["#include <Arduino.h>", '#include "platforms/wasm/js.h"']
-FILE_EXTENSIONS = [".ino", ".h", ".hpp", ".cpp"]
-MAX_COMPILE_ATTEMPTS = 1  # Occasionally the compiler fails for unknown reasons, but disabled because it increases the build time on failure.
-FASTLED_OUTPUT_DIR_NAME = "fastled_js"
+_PIO_BUILD_DIR = _JS_DIR / ".pio/build"
+_INDEX_HTML_SRC = _FASTLED_COMPILER_DIR / "index.html"
+_INDEX_CSS_SRC = _FASTLED_COMPILER_DIR / "index.css"
+_INDEX_JS_SRC = _FASTLED_COMPILER_DIR / "index.js"
 
 
+_WASM_COMPILER_SETTTINGS = _JS_DIR / "wasm_compiler_flags.py"
+_OUTPUT_FILES = ["fastled.js", "fastled.wasm"]
+_HEADERS_TO_INSERT = ["#include <Arduino.h>", '#include "platforms/wasm/js.h"']
+_FILE_EXTENSIONS = [".ino", ".h", ".hpp", ".cpp"]
+_MAX_COMPILE_ATTEMPTS = 1  # Occasionally the compiler fails for unknown reasons, but disabled because it increases the build time on failure.
+_FASTLED_OUTPUT_DIR_NAME = "fastled_js"
 
 
 def copy_files(src_dir: Path, js_src: Path) -> None:
@@ -101,7 +98,7 @@ def copy_files(src_dir: Path, js_src: Path) -> None:
 
 
 def compile(
-    js_dir: Path, build_mode: BuildMode, auto_clean: bool, no_platformio: bool
+    _JS_DIR: Path, build_mode: BuildMode, auto_clean: bool, no_platformio: bool
 ) -> int:
     print("Starting compilation process...")
     max_attempts = 1
@@ -124,7 +121,7 @@ def compile(
     def _open_process(cmd_list: list[str] = cmd_list) -> subprocess.Popen:
         out = subprocess.Popen(
             cmd_list,
-            cwd=js_dir,
+            cwd=_JS_DIR,
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             universal_newlines=True,
@@ -165,7 +162,7 @@ def insert_header(file: Path) -> None:
         content = f.read()
 
     # Remove existing includes
-    for header in HEADERS_TO_INSERT:
+    for header in _HEADERS_TO_INSERT:
         content = re.sub(
             rf"^.*{re.escape(header)}.*\n", "", content, flags=re.MULTILINE
         )
@@ -175,7 +172,7 @@ def insert_header(file: Path) -> None:
     content = re.sub(arduino_pattern, "", content, flags=re.MULTILINE)
 
     # Add new headers at the beginning
-    content = "\n".join(HEADERS_TO_INSERT) + "\n" + content
+    content = "\n".join(_HEADERS_TO_INSERT) + "\n" + content
 
     with open(file, "w") as f:
         f.write(content)
@@ -220,7 +217,7 @@ def insert_headers(
 def process_ino_files(src_dir: Path) -> None:
     transform_to_cpp(src_dir)
     exclusion_folders: List[Path] = []
-    insert_headers(src_dir, exclusion_folders, FILE_EXTENSIONS)
+    insert_headers(src_dir, exclusion_folders, _FILE_EXTENSIONS)
     print("Transform to cpp and insert header operations completed.")
 
 
@@ -250,6 +247,8 @@ def check_syntax_with_gcc(file_path, gcc_path="gcc"):
             "/js/fastled/src/",  # Add /js/fastled/src/ to the include path
             "-I",
             "/emsdk/upstream/emscripten/system/include",
+            "-I",
+            "/js/fastled/src/platforms/wasm/compiler",  # Arduino.h and Arduino.cpp
             file_path,
         ]
         cmd_str = subprocess.list2cmdline(cmd_list)
@@ -421,10 +420,10 @@ def find_project_dir(mapped_dir: Path) -> Path:
 
 
 def process_compile(
-    js_dir: Path, build_mode: BuildMode, auto_clean: bool, no_platformio: bool
+    _JS_DIR: Path, build_mode: BuildMode, auto_clean: bool, no_platformio: bool
 ) -> None:
     print("Starting compilation...")
-    rtn = compile(js_dir, build_mode, auto_clean, no_platformio=no_platformio)
+    rtn = compile(_JS_DIR, build_mode, auto_clean, no_platformio=no_platformio)
     print(f"Compilation return code: {rtn}")
     if rtn != 0:
         print("Compilation failed.")
@@ -450,32 +449,29 @@ def hash_file(file_path: Path) -> str:
 
 def main() -> int:
 
-
-
-    # assert JS_DIR.exists()
+    # assert _JS_DIR.exists()
     # assert ARDUINO_H_SRC.exists()
-    # assert INDEX_HTML_SRC.exists()
-    # assert INDEX_CSS_SRC.exists(), f"Index CSS not found at {INDEX_CSS_SRC}"
-    # assert INDEX_JS_SRC.exists()
-    # assert WASM_COMPILER_SETTTINGS.exists()
-    # assert FASTLED_SRC_PLATFORMS_WASM_COMPILER.exists()
-    # assert JS_DIR.exists(), f"JS_DIR does not exist: {JS_DIR}"
+    # assert _INDEX_HTML_SRC.exists()
+    # assert _INDEX_CSS_SRC.exists(), f"Index CSS not found at {_INDEX_CSS_SRC}"
+    # assert _INDEX_JS_SRC.exists()
+    # assert _WASM_COMPILER_SETTTINGS.exists()
+    # assert _FASTLED_SRC_PLATFORMS_WASM_COMPILER.exists()
+    # assert _JS_DIR.exists(), f"_JS_DIR does not exist: {_JS_DIR}"
     # assert ARDUINO_H_SRC.exists(), f"ARDUINO_H_SRC does not exist: {ARDUINO_H_SRC}"
-    # assert INDEX_HTML_SRC.exists(), f"INDEX_HTML_SRC does not exist: {INDEX_HTML_SRC}"
-    # assert INDEX_CSS_SRC.exists(), f"INDEX_CSS_SRC does not exist: {INDEX_CSS_SRC}"
-    # assert INDEX_JS_SRC.exists(), f"INDEX_JS_SRC does not exist: {INDEX_JS_SRC}"
+    # assert _INDEX_HTML_SRC.exists(), f"_INDEX_HTML_SRC does not exist: {_INDEX_HTML_SRC}"
+    # assert _INDEX_CSS_SRC.exists(), f"_INDEX_CSS_SRC does not exist: {_INDEX_CSS_SRC}"
+    # assert _INDEX_JS_SRC.exists(), f"_INDEX_JS_SRC does not exist: {_INDEX_JS_SRC}"
     # assert (
-    #     WASM_COMPILER_SETTTINGS.exists()
-    # ), f"WASM_COMPILER_SETTTINGS does not exist: {WASM_COMPILER_SETTTINGS}"
+    #     _WASM_COMPILER_SETTTINGS.exists()
+    # ), f"_WASM_COMPILER_SETTTINGS does not exist: {_WASM_COMPILER_SETTTINGS}"
 
     check_paths: list[Path] = [
-        JS_DIR,
-        ARDUINO_H_SRC,
-        INDEX_HTML_SRC,
-        INDEX_CSS_SRC,
-        INDEX_JS_SRC,
-        WASM_COMPILER_SETTTINGS,
-        FASTLED_SRC_PLATFORMS_WASM_COMPILER,
+        _JS_DIR,
+        _INDEX_HTML_SRC,
+        _INDEX_CSS_SRC,
+        _INDEX_JS_SRC,
+        _WASM_COMPILER_SETTTINGS,
+        _FASTLED_SRC_PLATFORMS_WASM_COMPILER,
     ]
 
     missing_paths = [p for p in check_paths if not p.exists()]
@@ -497,9 +493,9 @@ def main() -> int:
         os.environ["EMPROFILE"] = "2"
 
     try:
-        if JS_SRC.exists():
-            shutil.rmtree(JS_SRC)
-        JS_SRC.mkdir(parents=True, exist_ok=True)
+        if _JS_SRC.exists():
+            shutil.rmtree(_JS_SRC)
+        _JS_SRC.mkdir(parents=True, exist_ok=True)
         src_dir = find_project_dir(args.mapped_dir)
 
         any_only_flags = args.only_copy or args.only_insert_header or args.only_compile
@@ -509,14 +505,12 @@ def main() -> int:
         do_compile = not any_only_flags or args.only_compile
 
         if do_copy:
-            copy_files(src_dir, JS_SRC)
-            print("Copying Arduino.h to src/Arduino.h")
-            shutil.copy(ARDUINO_H_SRC, JS_SRC / "Arduino.h")
+            copy_files(src_dir, _JS_SRC)
             if args.only_copy:
                 return 0
 
         if do_insert_header:
-            process_ino_files(JS_SRC)
+            process_ino_files(_JS_SRC)
             if args.only_insert_header:
                 print("Transform to cpp and insert header operations completed.")
                 return 0
@@ -524,7 +518,7 @@ def main() -> int:
         if _CHECK_SYNTAX:
             print("Performing syntax check...")
             syntax_results = check_syntax(
-                directory_path=JS_SRC, gcc_path=_COMPILER_PATH
+                directory_path=_JS_SRC, gcc_path=_COMPILER_PATH
             )
             failed_checks = [r for r in syntax_results if not r.is_valid]
             if failed_checks:
@@ -549,7 +543,7 @@ def main() -> int:
                     build_mode = BuildMode.QUICK
 
                 process_compile(
-                    js_dir=JS_DIR,
+                    _JS_DIR=_JS_DIR,
                     build_mode=build_mode,
                     auto_clean=not args.disable_auto_clean,
                     no_platformio=no_platformio,
@@ -559,16 +553,16 @@ def main() -> int:
                 return 1
 
             def _get_build_dir_platformio() -> Path:
-                build_dirs = [d for d in PIO_BUILD_DIR.iterdir() if d.is_dir()]
+                build_dirs = [d for d in _PIO_BUILD_DIR.iterdir() if d.is_dir()]
                 if len(build_dirs) != 1:
                     raise RuntimeError(
-                        f"Expected exactly one build directory in {PIO_BUILD_DIR}, found {len(build_dirs)}: {build_dirs}"
+                        f"Expected exactly one build directory in {_PIO_BUILD_DIR}, found {len(build_dirs)}: {build_dirs}"
                     )
                 build_dir: Path = build_dirs[0]
                 return build_dir
 
             def _get_build_dir_cmake() -> Path:
-                return JS_DIR / "build"
+                return _JS_DIR / "build"
 
             if no_platformio:
                 build_dir = _get_build_dir_cmake()
@@ -576,45 +570,45 @@ def main() -> int:
                 build_dir = _get_build_dir_platformio()
 
             print("Copying output files...")
-            fastled_js_dir: Path = src_dir / FASTLED_OUTPUT_DIR_NAME
-            fastled_js_dir.mkdir(parents=True, exist_ok=True)
+            fastled__JS_DIR: Path = src_dir / _FASTLED_OUTPUT_DIR_NAME
+            fastled__JS_DIR.mkdir(parents=True, exist_ok=True)
 
             for file in ["fastled.js", "fastled.wasm"]:
                 _src = build_dir / file
-                _dst = fastled_js_dir / file
+                _dst = fastled__JS_DIR / file
                 print(f"Copying {_src} to {_dst}")
                 shutil.copy2(_src, _dst)
 
-            print(f"Copying {INDEX_HTML_SRC} to output directory")
-            shutil.copy2(INDEX_HTML_SRC, fastled_js_dir / "index.html")
-            print(f"Copying {INDEX_CSS_SRC} to output directory")
-            shutil.copy2(INDEX_CSS_SRC, fastled_js_dir / "index.css")
+            print(f"Copying {_INDEX_HTML_SRC} to output directory")
+            shutil.copy2(_INDEX_HTML_SRC, fastled__JS_DIR / "index.html")
+            print(f"Copying {_INDEX_CSS_SRC} to output directory")
+            shutil.copy2(_INDEX_CSS_SRC, fastled__JS_DIR / "index.css")
 
-            # copy all js files in FASTLED_COMPILER_DIR to output directory
-            Path(fastled_js_dir / "modules").mkdir(parents=True, exist_ok=True)
-            for _file in FASTLED_MODULES_DIR.iterdir():
+            # copy all js files in _FASTLED_COMPILER_DIR to output directory
+            Path(fastled__JS_DIR / "modules").mkdir(parents=True, exist_ok=True)
+            for _file in _FASTLED_MODULES_DIR.iterdir():
                 if _file.suffix == ".js":
                     print(f"Copying {_file} to output directory")
-                    shutil.copy2(_file, fastled_js_dir / "modules" / _file.name)
+                    shutil.copy2(_file, fastled__JS_DIR / "modules" / _file.name)
 
             fastled_js_mem = build_dir / "fastled.js.mem"
             fastled_wasm_map = build_dir / "fastled.wasm.map"
             fastled_js_symbols = build_dir / "fastled.js.symbols"
             if fastled_js_mem.exists():
                 print(f"Copying {fastled_js_mem} to output directory")
-                shutil.copy2(fastled_js_mem, fastled_js_dir / fastled_js_mem.name)
+                shutil.copy2(fastled_js_mem, fastled__JS_DIR / fastled_js_mem.name)
             if fastled_wasm_map.exists():
                 print(f"Copying {fastled_wasm_map} to output directory")
-                shutil.copy2(fastled_wasm_map, fastled_js_dir / fastled_wasm_map.name)
+                shutil.copy2(fastled_wasm_map, fastled__JS_DIR / fastled_wasm_map.name)
             if fastled_js_symbols.exists():
                 print(f"Copying {fastled_js_symbols} to output directory")
                 shutil.copy2(
-                    fastled_js_symbols, fastled_js_dir / fastled_js_symbols.name
+                    fastled_js_symbols, fastled__JS_DIR / fastled_js_symbols.name
                 )
             print("Copying index.js to output directory")
-            shutil.copy2(INDEX_JS_SRC, fastled_js_dir / "index.js")
+            shutil.copy2(_INDEX_JS_SRC, fastled__JS_DIR / "index.js")
             optional_input_data_dir = src_dir / "data"
-            output_data_dir = fastled_js_dir / optional_input_data_dir.name
+            output_data_dir = fastled__JS_DIR / optional_input_data_dir.name
 
             # Handle data directory if it exists
             manifest: list[dict] = []
@@ -663,9 +657,9 @@ def main() -> int:
             # Write manifest file even if empty
             print("Writing manifest files.json")
             manifest_json_str = json.dumps(manifest, indent=2, sort_keys=True)
-            with open(fastled_js_dir / "files.json", "w") as f:
+            with open(fastled__JS_DIR / "files.json", "w") as f:
                 f.write(manifest_json_str)
-        cleanup(args, JS_SRC)
+        cleanup(args, _JS_SRC)
 
         print("Compilation process completed successfully")
         return 0

fastled-1.2.44/compiler/compile_lock.py

@@ -0,0 +1,3 @@
+import threading
+
+COMPILE_LOCK = threading.Lock()

{fastled-1.2.43 → fastled-1.2.44}/compiler/init_runtime.py

@@ -1,26 +1,24 @@
-
-import os
-from pathlib import Path
 import glob
+import os
 import warnings
 from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
 
 HERE = Path(__file__).parent
 
 
 _COMPILER_DIR = Path("/js/compiler")
-_FASTLED_SRC_DIR = Path("/js/fastled/src")
-_WASM_DIR = _FASTLED_SRC_DIR / "platforms" / "wasm"
-_FASTLED_COMPILER_DIR = _WASM_DIR / "compiler"
+_FASTLED_COMPILER_DIR = Path("/js/fastled/src/platforms/wasm/compiler")
+
 
 def copy_task(src: str | Path) -> None:
     src = Path(src)
     if "entrypoint.sh" in str(src):
         return
     link_dst = Path("/js") / src.name
-    
+
     # Handle shell scripts
-    if src.suffix == '.sh':
+    if src.suffix == ".sh":
         os.system(f"dos2unix {src} && chmod +x {src}")
 
     # if link exists, remove it
@@ -31,7 +29,6 @@ def copy_task(src: str | Path) -> None:
         except Exception as e:
             warnings.warn(f"Failed to remove {link_dst}: {e}")
 
-        
     if not link_dst.exists():
         print(f"Linking {src} to {link_dst}")
         try:
@@ -44,8 +41,18 @@ def copy_task(src: str | Path) -> None:
 
 def make_links() -> None:
     # Define file patterns to include
-    patterns = ['*.h', '*.py', '*.css', '*.sh', "*.ino", "*.hpp", "*.cpp", "*.ini", "*.txt"]
-    
+    patterns = [
+        "*.h",
+        "*.hpp",
+        "*.cpp",
+        "*.py",
+        "*.css",
+        "*.sh",
+        "*.ino",
+        "*.ini",
+        "*.txt",
+    ]
+
     # Get all matching files in compiler directory
     files = []
     for pattern in patterns: