wexample-wex-addon-dev-javascript 8.1.5__py3-none-any.whl → 8.2.0__py3-none-any.whl

wexample_wex_addon_dev_javascript/common/npm_registry_gateway.py

@@ -24,6 +24,28 @@ class NpmRegistryGateway(AbstractGateway):
         if self.token:
             self.default_headers["Authorization"] = f"Bearer {self.token}"
 
+    def has_package(self, package: str) -> bool:
+        """Return True iff `package` is known to this registry, at any version.
+
+        A 404 means it was never published — the signal the first-publication
+        bootstrap reads. An unreachable registry raises instead of answering
+        False, so that a network glitch is never mistaken for a new package.
+        """
+        response = self.make_request(
+            endpoint=self._encode_package_name(package),
+            expected_status_codes=[200, 404],
+            fatal_if_unexpected=False,
+            quiet=True,
+        )
+        if response is None:
+            from wexample_helpers.error.gateway_error import GatewayError
+
+            raise GatewayError(
+                f"Registry {self.base_url} is unreachable: cannot tell whether "
+                f"{package} has ever been published."
+            )
+        return response.status_code == 200
+
     def has_version(self, package: str, version: str) -> bool:
         """Return True iff `package@version` is published on this registry.
 
@@ -32,9 +54,8 @@ class NpmRegistryGateway(AbstractGateway):
         registries that don't expose per-version URLs. Returns False on
         404 (unknown package or version not yet propagated).
         """
-        encoded = package.replace("/", "%2F")
         response = self.make_request(
-            endpoint=encoded,
+            endpoint=self._encode_package_name(package),
             expected_status_codes=[200, 404],
             fatal_if_unexpected=False,
             quiet=True,
@@ -42,3 +63,7 @@ class NpmRegistryGateway(AbstractGateway):
         if response is None or response.status_code != 200:
             return False
         return version in response.json().get("versions", {})
+
+    def _encode_package_name(self, package: str) -> str:
+        """A scoped name carries a slash, which the URL must not read as a path."""
+        return package.replace("/", "%2F")

wexample_wex_addon_dev_javascript/const/registry.py

@@ -0,0 +1,5 @@
+"""Npm registry defaults shared by the publication paths of this addon."""
+
+from __future__ import annotations
+
+NPM_REGISTRY_URL_DEFAULT = "https://registry.npmjs.org"

wexample_wex_addon_dev_javascript/services/node/commands/service/install_local.py

@@ -54,6 +54,14 @@ def node__service__install_local(
     # newer local source exists, so the deterministic wiring is a forced
     # symlink over node_modules/ — resolved by each package's declared scoped
     # name, which differs from its directory name.
+    #
+    # Only the javascript suite is linked here. The npm face of a PHP package
+    # (`@wexample/symfony-loader` → `vendor/wexample/symfony-loader/assets`) is
+    # not: the app's package.json must declare it as `link:` so that the
+    # `yarn install` above makes the symlink itself. Declared as `file:`, yarn
+    # copies it, and the copy is what TypeScript falls back to when a mapped
+    # file goes missing — see the symfony-design-system knowledge page
+    # contributing/assets-as-npm-package.
     script = f"""
 set -e
 cd {APP_DIR}

wexample_wex_addon_dev_javascript/workdir/javascript_package_workdir.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from wexample_helpers.classes.private_field import private_field
 from wexample_helpers.decorator.base_class import base_class
 from wexample_helpers.helper.string import string_to_kebab_case
 from wexample_helpers_git.helper.git import (
@@ -22,9 +23,18 @@ if TYPE_CHECKING:
         FrameworkPackageSuiteWorkdir,
     )
 
+    from wexample_wex_addon_dev_javascript.common.npm_registry_gateway import (
+        NpmRegistryGateway,
+    )
+
 
 @base_class
 class JavascriptPackageWorkdir(JavascriptWorkdir):
+    _first_publication: bool = private_field(
+        default=False,
+        description="Set when this run created the package on the registry",
+    )
+
     def get_package_dependency_name(self) -> str:
         return self.get_package_import_name()
 
@@ -131,9 +141,80 @@ class JavascriptPackageWorkdir(JavascriptWorkdir):
 
         return UPGRADE_TYPE_MAJOR
 
+    def _declare_trusted_publisher(self) -> None:
+        """Let the CI workflow publish the next versions, through `npm trust`.
+
+        The token npm keeps in ~/.npmrc is refused for account changes, so a
+        short-lived session is opened for this alone — in its own config, so
+        the everyday token is left untouched — and revoked right after. npm
+        asks the user to confirm both the login and the declaration through
+        links it prints, which any device can open.
+        """
+        import os
+        import shutil
+        import tempfile
+
+        from wexample_helpers.helper.user import user_get_real_gid, user_get_real_uid
+
+        repository, workflow = self._get_trusted_publisher_target()
+        config_dir = tempfile.mkdtemp(prefix="npm-trust-")
+        os.chown(config_dir, user_get_real_uid(), user_get_real_gid())
+        env = {"NPM_CONFIG_USERCONFIG": os.path.join(config_dir, ".npmrc")}
+
+        self.log("Declaring the CI as trusted publisher — confirm the two links npm prints.")
+        try:
+            self._shell_run_node_command(["npm", "login", "--auth-type=web"], env)
+            self._shell_run_node_command(
+                [
+                    "npm",
+                    "trust",
+                    "github",
+                    self.get_project_name(),
+                    "--file",
+                    workflow,
+                    "--repo",
+                    repository,
+                    "--allow-publish",
+                    "--yes",
+                ],
+                env,
+            )
+        finally:
+            try:
+                self._shell_run_node_command(["npm", "logout"], env)
+            except Exception:
+                pass
+            shutil.rmtree(config_dir, ignore_errors=True)
+
+        self.success(f"CI declared as trusted publisher of {self.get_project_name()}.")
+
     def _get_critical_directories(self) -> list[str]:
         return ["src"]
 
+    def _get_first_publication_notice(self) -> str:
+        """Why this first publication is slow, and what comes after it."""
+        return (
+            f"First publication of {self.get_project_name()}: npm usually needs "
+            "5 to 15 minutes to list a brand-new package.\n"
+            "Next versions publish from CI, which npm rejects until it is declared "
+            "as a trusted publisher. This is done right after the listing, and npm "
+            "will ask you to open two links to confirm: a login, then the "
+            "declaration itself."
+        )
+
+    def _get_manual_trusted_publisher_notice(self) -> str:
+        """The by-hand fallback when the declaration could not be scripted."""
+        repository, workflow = self._get_trusted_publisher_target()
+
+        return (
+            f"Could not declare the trusted publisher of {self.get_project_name()}; "
+            "its next version will fail to publish until it is done by hand:\n"
+            f"  npmjs.com → {self.get_project_name()} → Settings → Trusted Publisher "
+            "→ GitHub Actions\n"
+            f"  repository: {repository}\n"
+            f"  workflow: {workflow}"
+        )
+
     def _get_readme_content(self) -> ReadmeContentConfigValue | None:
         from wexample_wex_addon_dev_javascript.config_value.javascript_package_readme_config_value import (
             JavascriptPackageReadmeContentConfigValue,
@@ -141,6 +222,25 @@ class JavascriptPackageWorkdir(JavascriptWorkdir):
 
         return JavascriptPackageReadmeContentConfigValue(workdir=self)
 
+    def _get_registry_gateway(self) -> NpmRegistryGateway:
+        """Gateway over the registry this package publishes to."""
+        from wexample_wex_addon_dev_javascript.common.npm_registry_gateway import (
+            NpmRegistryGateway,
+        )
+        from wexample_wex_addon_dev_javascript.const.registry import (
+            NPM_REGISTRY_URL_DEFAULT,
+        )
+
+        config = self.get_runtime_config()
+
+        return NpmRegistryGateway(
+            base_url=config.search("npm.registry_url").get_str_or_none()
+            or NPM_REGISTRY_URL_DEFAULT,
+            token=config.search("npm.api_token").get_str_or_none(),
+            io=self.io,
+            timeout=10,
+        )
+
     def _get_suite_workdir_class(self) -> type[FrameworkPackageSuiteWorkdir]:
         from wexample_wex_addon_dev_javascript.workdir.javascript_packages_suite_workdir import (
             JavascriptPackagesSuiteWorkdir,
@@ -148,10 +248,37 @@ class JavascriptPackageWorkdir(JavascriptWorkdir):
 
         return JavascriptPackagesSuiteWorkdir
 
+    def _get_trusted_publisher_target(self) -> tuple[str, str]:
+        """The `owner/repo` and workflow file npm must trust to publish."""
+        from urllib.parse import urlparse
+
+        url = self.get_app_config_file().read_parsed().get("repository") or ""
+        repository = urlparse(url.removeprefix("git+")).path.strip("/")
+
+        return repository.removesuffix(".git"), "publish.yml"
+
+    def _post_publish(self) -> None:
+        # After the registry wait on purpose: npm can only trust a package it
+        # already lists.
+        if not self._first_publication:
+            return
+        try:
+            self._declare_trusted_publisher()
+        except Exception:
+            self.warning(self._get_manual_trusted_publisher_notice())
+
     def _publish(self, force: bool = False) -> None:
         """Push a git tag to the deployment remote to trigger a CI/CD publication workflow."""
         from wexample_helpers_git.helper.git import git_push_tag
 
+        # Only public npm has the chicken-and-egg problem: a private registry
+        # (GitLab) lets its CI job token create the package itself.
+        if self.is_published_publicly() and not self._get_registry_gateway().has_package(
+            self.get_project_name()
+        ):
+            self._publish_first_version()
+            return
+
         remote = self._get_deployment_remote_name()
         if not remote:
             self.log("No deployment remote configured, skipping publication.")
@@ -167,11 +294,36 @@ class JavascriptPackageWorkdir(JavascriptWorkdir):
 
         git_push_tag(tag, cwd=cwd, remote=remote, inherit_stdio=True)
 
+    def _publish_first_version(self) -> None:
+        """Create the package on the registry from here, bypassing the CI workflow.
+
+        The workflow authenticates by OIDC alone (`id-token: write`, no token),
+        which npm only honours once the package has a trusted publisher — and
+        that is declared on a package settings page that does not exist until
+        the package does. So the very first version cannot come from CI, and
+        the CI tag is deliberately not pushed: it would start a run that can
+        only fail. Subsequent versions take the normal tag path again.
+        """
+        manager = self._get_package_manager()
+        package = self.get_project_name()
+
+        self.log(
+            f"{package} is not on the registry yet: publishing this first "
+            "version locally, the workflow cannot create it."
+        )
+
+        # Same two steps as the workflow: publishing runs prepublishOnly,
+        # which type-checks against dependencies that must be installed.
+        self._shell_run_node_command([manager, "install"])
+        self._shell_run_node_command([manager, "publish", "--access", "public"])
+
+        self._first_publication = True
+        self.success(f"{package} now exists on the registry.")
+        self.warning(self._get_first_publication_notice())
+
     def _refresh_lockfile(self) -> None:
         import shutil
 
-        from wexample_helpers.helper.shell import shell_run
-
         for lockfile, command in self._LOCKFILE_REFRESH_COMMANDS.items():
             if not (self.get_path() / lockfile).exists():
                 continue
@@ -182,7 +334,7 @@ class JavascriptPackageWorkdir(JavascriptWorkdir):
                     f"available on this machine. A stale lockfile would break "
                     f"the strict CI install."
                 )
-            shell_run(command, cwd=self.get_path())
+            self._shell_run_node_command(command)
             return
 
     def _wait_for_registry(self) -> None:
@@ -196,25 +348,9 @@ class JavascriptPackageWorkdir(JavascriptWorkdir):
             PollingCallbackManager,
         )
 
-        from wexample_wex_addon_dev_javascript.common.npm_registry_gateway import (
-            NpmRegistryGateway,
-        )
-
         package = self.get_project_name()
         version = self.get_setup_version()
-
-        registry_base = (
-            self.get_runtime_config().search("npm.registry_url").get_str_or_none()
-            or "https://registry.npmjs.org"
-        )
-        token = self.get_runtime_config().search("npm.api_token").get_str_or_none()
-
-        gateway = NpmRegistryGateway(
-            base_url=registry_base,
-            token=token,
-            io=self.io,
-            timeout=10,
-        )
+        gateway = self._get_registry_gateway()
 
         max_attempts = 40
         delay_seconds = 30
@@ -222,9 +358,16 @@ class JavascriptPackageWorkdir(JavascriptWorkdir):
         self.log(f"Waiting for {package}@{version} to appear on registry…")
 
         def on_retry(attempt, max_a, delay, _exc, _msg) -> None:
-            self.log(
-                f"Not yet available (attempt {attempt}/{max_a}), retrying in {delay}s…"
-            )
+            if not self._first_publication:
+                self.log(
+                    f"Not yet available (attempt {attempt}/{max_a}), retrying in {delay}s…"
+                )
+            # A first listing is expected to be slow and was announced as
+            # such: one line every two minutes is enough to show it is alive.
+            elif attempt % 4 == 0:
+                self.log(
+                    f"npm is still listing {package} ({attempt * delay // 60} min)…"
+                )
 
         PollingCallbackManager(
             callback=lambda: True if gateway.has_version(package, version) else None,
@@ -238,3 +381,4 @@ class JavascriptPackageWorkdir(JavascriptWorkdir):
         ).run()
 
         self.success(f"{package}@{version} is available.")
+

wexample_wex_addon_dev_javascript/workdir/javascript_workdir.py

@@ -24,6 +24,21 @@ if TYPE_CHECKING:
 
 @base_class
 class JavascriptWorkdir(WithAiWorkdirMixin, CodeBaseWorkdir):
+    # What a test file looks like, whatever the runner the package picked.
+    _TEST_FILE_SUFFIXES: tuple[str, ...] = tuple(
+        f".{kind}.{extension}"
+        for kind in ("test", "spec")
+        for extension in ("js", "jsx", "mjs", "cjs", "ts", "tsx", "mts", "cts")
+    )
+    # Lockfile → the package manager that wrote it. Order matters: a repo
+    # carrying several lockfiles is read as the first one listed, exactly as
+    # JavascriptPackageWorkdir._LOCKFILE_REFRESH_COMMANDS does.
+    _LOCKFILE_PACKAGE_MANAGERS: dict[str, str] = {
+        "package-lock.json": "npm",
+        "pnpm-lock.yaml": "pnpm",
+        "yarn.lock": "yarn",
+    }
+
     def get_app_config_file(self, reload: bool = True) -> JavascriptPackageJsonFile:
         from wexample_wex_addon_dev_javascript.file.javascript_package_json_file import (
             JavascriptPackageJsonFile,
@@ -51,6 +66,17 @@ class JavascriptWorkdir(WithAiWorkdirMixin, CodeBaseWorkdir):
 
         return options
 
+    def has_tests(self) -> bool:
+        # The tests/ directory itself is filestate-managed scaffolding and
+        # exists for every JavaScript package; only actual test files count.
+        tests_path = self.get_path() / "tests"
+        if not tests_path.is_dir():
+            return False
+        return any(
+            path.name.endswith(self._TEST_FILE_SUFFIXES)
+            for path in tests_path.rglob("*")
+        )
+
     def prepare_value(self, raw_value: DictConfig | None = None) -> DictConfig:
         from wexample_filestate.const.disk import DiskItemType
 
@@ -124,6 +150,32 @@ class JavascriptWorkdir(WithAiWorkdirMixin, CodeBaseWorkdir):
 
         return raw_value
 
+    def test_run(self, format: str | None = None) -> None:
+        """Run the package's own `test` script; raise on failure.
+
+        A JavaScript package names its runner itself — vitest, jest, plain
+        node — so the script declared in package.json is the only portable
+        entry point. `format` is ignored: unlike pytest-cov, nothing here
+        produces a coverage report to shape.
+        """
+        manager = self._get_package_manager()
+        scripts = self.get_app_config_file().read_parsed().get("scripts", {})
+
+        if "test" not in scripts:
+            raise NotImplementedError(
+                f"{self.get_project_name()} ships test files under tests/ but its "
+                "package.json declares no `test` script; add one so they can run."
+            )
+
+        # Tests import the dependencies, which the publication flow never
+        # installs on its own — a fresh clone would fail on the first import
+        # rather than on a real assertion.
+        if not any(self.get_path().glob("node_modules/*")):
+            self.log(f"Installing {self.get_project_name()} dependencies before tests…")
+            self._shell_run_node_command([manager, "install"])
+
+        self._shell_run_node_command([manager, "run", "test"])
+
     def _canonicalize_dep_name(self, name: str) -> str:
         return name
 
@@ -150,3 +202,46 @@ class JavascriptWorkdir(WithAiWorkdirMixin, CodeBaseWorkdir):
 
     def _default_dependency_operator(self) -> str:
         return "^"
+
+    def _get_node_command_environment(self) -> dict[str, str]:
+        """Environment a node command needs to be the invoking user's own."""
+        import os
+
+        from wexample_helpers.helper.user import user_get_real_home, user_get_real_path
+
+        # Under sudo HOME still points at /root: npm would read root's .npmrc
+        # (no registry token) and root's cache, which the lifecycle scripts —
+        # dropped back to the invoking uid by npm — then cannot even write.
+        # PATH is sudo's secure_path: the distribution's node, not nvm's.
+        return {
+            **os.environ,
+            "HOME": user_get_real_home(),
+            "PATH": user_get_real_path(),
+        }
+
+    def _get_package_manager(self) -> str:
+        """The package manager this repository uses, told by its lockfile."""
+        for lockfile, manager in self._LOCKFILE_PACKAGE_MANAGERS.items():
+            if (self.get_path() / lockfile).exists():
+                return manager
+        return "npm"
+
+    def _shell_run_node_command(
+        self, cmd: list[str], extra_env: dict[str, str] | None = None
+    ) -> None:
+        """Run a node toolchain command as the user who invoked wex.
+
+        Publication carries @as_sudo, so the process is root by the time it
+        reaches here: npm run as root would use root's node, token and cache.
+        Earlier release steps ran as root too, so whatever they wrote in the
+        workdir (package.json, lockfile…) is handed back first — npm could not
+        rewrite it otherwise.
+        """
+        from wexample_helpers.helper.shell import shell_run
+        from wexample_helpers.helper.user import user_run_as_real_user
+
+        self.restore_real_user_ownership()
+        env = {**self._get_node_command_environment(), **(extra_env or {})}
+
+        with user_run_as_real_user():
+            shell_run(cmd, cwd=self.get_path(), env=env, inherit_stdio=True)

{wexample_wex_addon_dev_javascript-8.1.5.dist-info → wexample_wex_addon_dev_javascript-8.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wexample-wex-addon-dev-javascript
-Version: 8.1.5
+Version: 8.2.0
 Summary: Extends wex with JavaScript support: enforces JS/TS project layout and symlinks local npm packages into node_modules
 Author-Email: weeger <contact@wexample.com>
 License: MIT
@@ -13,8 +13,8 @@ Requires-Dist: attrs>=23.1.0
 Requires-Dist: cattrs>=23.1.0
 Requires-Dist: wexample-api>=6.8.0
 Requires-Dist: wexample-filestate-javascript>=6.6.0
-Requires-Dist: wexample-wex-addon-ai>=15.0.0
-Requires-Dist: wexample-wex-addon-app>=31.0.0
+Requires-Dist: wexample-wex-addon-ai>=16.0.0
+Requires-Dist: wexample-wex-addon-app>=32.0.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
@@ -22,7 +22,7 @@ Description-Content-Type: text/markdown
 
 # wex_addon_dev_javascript
 
-Version: 8.1.5
+Version: 8.2.0
 
 `wex-addon-dev-javascript` extends wex for JavaScript and TypeScript developers: it enforces a standard project layout — requiring `package.json`, `tsconfig.json`, `.npmrc`, `src/`, `tests/`, and the corresponding `.gitignore` rules — and in local environments symlinks locally-developed npm packages directly into a running container's `node_modules/` so monorepo packages resolve without a registry publish cycle. It also contributes a `node` service and a `vite` service, each backed by Docker Compose, where the vite service patches `allowedHosts` in `vite.config.ts` for reverse-proxy use and the node service handles lockfile refresh, annotated-tag release, and registry polling for npm package suites managed through wex.
 
@@ -251,8 +251,8 @@ Visit the [Wexample Suite documentation](https://docs.wexample.com) for the comp
 - cattrs: >=23.1.0
 - wexample-api: >=6.8.0
 - wexample-filestate-javascript: >=6.6.0
-- wexample-wex-addon-ai: >=15.0.0
-- wexample-wex-addon-app: >=31.0.0
+- wexample-wex-addon-ai: >=16.0.0
+- wexample-wex-addon-app: >=32.0.0
 
 ## Versioning & Compatibility Policy
 

{wexample_wex_addon_dev_javascript-8.1.5.dist-info → wexample_wex_addon_dev_javascript-8.2.0.dist-info}/RECORD

@@ -1,13 +1,14 @@
-wexample_wex_addon_dev_javascript-8.1.5.dist-info/METADATA,sha256=IrwC5f4cMAgzWyNd5egcVYCm1z-0LjneRJeDK7OrhxI,18012
-wexample_wex_addon_dev_javascript-8.1.5.dist-info/WHEEL,sha256=VP-D4TPS230sME9Z3vb3INXvo1yt0924YRm5AOsk_dE,90
-wexample_wex_addon_dev_javascript-8.1.5.dist-info/entry_points.txt,sha256=WwYdg3RL2Ey1fg4JNNkcQxZcQRgZSgPLLzSDi6lbYgI,143
+wexample_wex_addon_dev_javascript-8.2.0.dist-info/METADATA,sha256=jQSdi-wtyOIrG76xCCSSOrMF4_UTHmj0i24IjqRQpj8,18012
+wexample_wex_addon_dev_javascript-8.2.0.dist-info/WHEEL,sha256=Y8xFLOH-FrS4gLE6ON4ti06sl2W_9QUDiRaTK3tfwig,91
+wexample_wex_addon_dev_javascript-8.2.0.dist-info/entry_points.txt,sha256=WwYdg3RL2Ey1fg4JNNkcQxZcQRgZSgPLLzSDi6lbYgI,143
 wexample_wex_addon_dev_javascript/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_javascript/__pycache__/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_javascript/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wexample_wex_addon_dev_javascript/common/npm_registry_gateway.py,sha256=fdmsO6DZVvAQw1o3QmtjLBq0Dr1i_EAfnKvxQx5VdIw,1657
+wexample_wex_addon_dev_javascript/common/npm_registry_gateway.py,sha256=jcAIOZN1eiPeRSjradY095VI93ne86ijbVAZcXzCKpQ,2742
 wexample_wex_addon_dev_javascript/config_value/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_javascript/config_value/javascript_package_readme_config_value.py,sha256=FaYjL6A6Zv8sYnz4cWqD4DsrNO9EMYvSi1-8GCbmNvs,522
 wexample_wex_addon_dev_javascript/const/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wexample_wex_addon_dev_javascript/const/registry.py,sha256=pkGypHvxhPeb6-Quyv8Vodt8LIBmbPYHV7ibL1TemSw,168
 wexample_wex_addon_dev_javascript/const/tags.py,sha256=qirMGuj7UqenempTZeQfJfMa_bC7mt-yLD_BkLnMnKE,307
 wexample_wex_addon_dev_javascript/file/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
 wexample_wex_addon_dev_javascript/file/javascript_package_json_file.py,sha256=yn1ltv3oBYNg1OvUytJ4PEzH8FSJS2KcIKK8y-cMrl4,2906
@@ -25,7 +26,7 @@ wexample_wex_addon_dev_javascript/services/__init__.py,sha256=47DEQpj8HBSa-_TImW
 wexample_wex_addon_dev_javascript/services/node/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_javascript/services/node/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wexample_wex_addon_dev_javascript/services/node/commands/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wexample_wex_addon_dev_javascript/services/node/commands/service/install_local.py,sha256=DtR5jrC2H_7h-TU1NhcH4TzzrqZ8_p7DMCfSQ7_GzsE,2773
+wexample_wex_addon_dev_javascript/services/node/commands/service/install_local.py,sha256=U4WjWabvGhlET5zocCfKIT-1WwQJbRK0GOGD7krwTnE,3283
 wexample_wex_addon_dev_javascript/services/node/commands/service/refresh_lock.py,sha256=qlGmvYxjnXxrr1DILjBBLfp9kTruuBe-5SYEzxvVNIA,2204
 wexample_wex_addon_dev_javascript/services/node/docker/.wex.yml,sha256=JdIF6nGkFcfi76yZYGlXxeWfOK4eAUSV_gAn6i3hk2w,32
 wexample_wex_addon_dev_javascript/services/node/docker/docker-compose.yml,sha256=GF22uk3PDtywP_GAF0RbfJ7lQ5P5nuuwJQE9ohwQh28,362
@@ -45,7 +46,7 @@ wexample_wex_addon_dev_javascript/services/vite/docker/.wex.yml,sha256=JdIF6nGkF
 wexample_wex_addon_dev_javascript/services/vite/docker/docker-compose.yml,sha256=M7ejIcht0GxuEAEEcK3urBIrXA66JwYrr5EPUA9nMMM,595
 wexample_wex_addon_dev_javascript/services/vite/service.yml,sha256=8mFPv49QbKA3klHFbNK73QOB7ryy38zFeLiQB3gfDys,184
 wexample_wex_addon_dev_javascript/workdir/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wexample_wex_addon_dev_javascript/workdir/javascript_package_workdir.py,sha256=aUO2RdXlExfwIlnSexWGwc-Oh7QBMKKNv6sPgCIev2Q,9302
+wexample_wex_addon_dev_javascript/workdir/javascript_package_workdir.py,sha256=mRTWei7NtmUzr5Ht1ZYVOdv_18tZ6BzruJMTuzy20s4,15612
 wexample_wex_addon_dev_javascript/workdir/javascript_packages_suite_workdir.py,sha256=b0QoTWlNYOYfpqEb8vYzL4WRoY0WwBhYOFUoRc4oySI,928
-wexample_wex_addon_dev_javascript/workdir/javascript_workdir.py,sha256=oKBj-tOV-EH9kqiXnKUE7sKLKU4v0ta4IQr-zLEWgFI,5272
-wexample_wex_addon_dev_javascript-8.1.5.dist-info/RECORD,,
+wexample_wex_addon_dev_javascript/workdir/javascript_workdir.py,sha256=Wff6pgdPzsaf2zDfkVKytVHHp8rAXaXesz0G8Svh5z4,9529
+wexample_wex_addon_dev_javascript-8.2.0.dist-info/RECORD,,

{wexample_wex_addon_dev_javascript-8.1.5.dist-info → wexample_wex_addon_dev_javascript-8.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.4.9)
+Generator: pdm-backend (2.4.10)
 Root-Is-Purelib: true
 Tag: py3-none-any