Flask-Node 0.1.0__py3-none-any.whl

flask_node/__init__.py

@@ -0,0 +1,15 @@
+"""Generic Node/npm infrastructure for Flask applications."""
+from .extension import Node
+from .manager import NodeManager
+from .package import Package
+from .runner import CommandResult, CommandRunner
+from .exceptions import (
+    NodeError, ConfigurationError, EnvironmentError, ExecutableNotFoundError,
+    CommandExecutionError, DependencyConflictError, PackageNotFoundError,
+    AssetResolutionError,
+)
+
+__all__ = ["Node", "NodeManager", "Package", "CommandResult", "CommandRunner", "NodeError",
+           "ConfigurationError", "EnvironmentError", "ExecutableNotFoundError",
+           "CommandExecutionError", "DependencyConflictError", "PackageNotFoundError",
+           "AssetResolutionError"]

flask_node/cli.py

@@ -0,0 +1,78 @@
+"""Thin Flask CLI adapters."""
+from functools import wraps
+import json
+import click
+from flask import current_app
+from flask.cli import with_appcontext
+from .exceptions import NodeError
+
+
+def operation(function):
+    @wraps(function)
+    @with_appcontext
+    def wrapped(*args, **kwargs):
+        try:
+            return function(current_app.extensions["node"], *args, **kwargs)
+        except NodeError as exc:
+            raise click.ClickException(str(exc)) from exc
+    return wrapped
+
+
+@click.group("node")
+def node_cli():
+    """Manage the application's isolated Node environment."""
+
+
+@node_cli.command("init")
+@operation
+def initialize(manager):
+    """Create or validate the managed package manifest."""
+    click.echo(f"Initialized {manager.initialize()}")
+
+
+@node_cli.command()
+@click.argument("package", required=False)
+@click.option("--version")
+@click.option("--dev", is_flag=True)
+@operation
+def install(manager, package, version, dev):
+    """Install declarations or a registry package."""
+    manager.install(package, version, dev=dev, capture_output=False)
+
+
+@node_cli.command()
+@click.argument("package")
+@operation
+def uninstall(manager, package):
+    """Remove an npm dependency."""
+    manager.uninstall(package, capture_output=False)
+
+
+@node_cli.command()
+@operation
+def ci(manager):
+    """Install reproducibly from the existing lockfile."""
+    manager.ci(capture_output=False)
+
+
+@node_cli.command()
+@operation
+def status(manager):
+    """Show environment and executable locations without launching commands."""
+    click.echo(json.dumps(manager.status(), indent=2))
+
+
+@node_cli.command(context_settings={"ignore_unknown_options": True})
+@click.argument("args", nargs=-1, type=click.UNPROCESSED)
+@operation
+def npm(manager, args):
+    """Forward arguments to npm in the managed directory."""
+    manager.npm(*args, capture_output=False)
+
+
+@node_cli.command(context_settings={"ignore_unknown_options": True})
+@click.argument("args", nargs=-1, type=click.UNPROCESSED)
+@operation
+def npx(manager, args):
+    """Forward arguments to npx in the managed directory."""
+    manager.npx(*args, capture_output=False)

flask_node/exceptions.py

@@ -0,0 +1,41 @@
+"""Public exceptions raised by Flask-Node."""
+
+
+class NodeError(Exception):
+    """Base error for managed Node operations."""
+
+
+class ConfigurationError(NodeError):
+    pass
+
+
+class EnvironmentError(NodeError):
+    pass
+
+
+class ExecutableNotFoundError(NodeError):
+    pass
+
+
+class CommandExecutionError(NodeError):
+    def __init__(self, message: str, *, args: tuple[str, ...], cwd: str,
+                 returncode: int | None = None, stdout: str | None = None,
+                 stderr: str | None = None):
+        super().__init__(message)
+        self.command = args
+        self.cwd = cwd
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr
+
+
+class DependencyConflictError(NodeError):
+    pass
+
+
+class PackageNotFoundError(NodeError):
+    pass
+
+
+class AssetResolutionError(NodeError):
+    pass

flask_node/extension.py

@@ -0,0 +1,76 @@
+"""Flask integration with no initialization side effects."""
+from pathlib import Path
+from typing import Any
+from flask import Flask, current_app
+from .exceptions import ConfigurationError
+from .manager import NodeManager
+from .runner import CommandRunner, CommandResult
+from .package import Package
+
+
+class Node:
+    def __init__(self, app: Flask | None = None, *, runner: CommandRunner | None = None):
+        self._runner = runner
+        if app is not None:
+            self.init_app(app)
+
+    def init_app(self, app: Flask) -> None:
+        if "node" in app.extensions:
+            raise ConfigurationError("Flask-Node is already initialized on this application.")
+        defaults = {"NODE_DIR": ".node", "NODE_BIN": "node", "NODE_NPM_BIN": "npm", "NODE_NPX_BIN": "npx"}
+        for key, default in defaults.items():
+            app.config.setdefault(key, default)
+        value = app.config["NODE_DIR"]
+        if not isinstance(value, (str, Path)) or not str(value).strip():
+            raise ConfigurationError("NODE_DIR must be a nonempty path.")
+        directory = Path(value)
+        if not directory.is_absolute():
+            directory = Path(app.root_path) / directory
+        for key in ("NODE_BIN", "NODE_NPM_BIN", "NODE_NPX_BIN"):
+            if not isinstance(app.config[key], str) or not app.config[key].strip():
+                raise ConfigurationError(f"{key} must be a nonempty executable path.")
+        app.extensions["node"] = NodeManager(
+            directory, node_bin=app.config["NODE_BIN"], npm_bin=app.config["NODE_NPM_BIN"],
+            npx_bin=app.config["NODE_NPX_BIN"], runner=self._runner,
+        )
+        from .cli import node_cli
+        app.cli.add_command(node_cli)
+
+    def get_manager(self, app: Flask | None = None) -> NodeManager:
+        application = app if app is not None else current_app
+        manager = application.extensions.get("node")
+        if not isinstance(manager, NodeManager):
+            raise ConfigurationError("Initialize Flask-Node before using its API.")
+        return manager
+
+    # Delegate the documented manager API while keeping application state local.
+    def initialize(self) -> Path:
+        return self.get_manager().initialize()
+
+    def require(self, name: str, version: str = "*", *, dev: bool = False) -> None:
+        return self.get_manager().require(name, version, dev=dev)
+
+    def install(self, name: str | None = None, version: str | None = None, *, dev: bool = False,
+                capture_output: bool = True) -> CommandResult:
+        return self.get_manager().install(name, version, dev=dev, capture_output=capture_output)
+
+    def uninstall(self, name: str, *, capture_output: bool = True) -> CommandResult:
+        return self.get_manager().uninstall(name, capture_output=capture_output)
+
+    def npm(self, *args: str, capture_output: bool = True) -> CommandResult:
+        return self.get_manager().npm(*args, capture_output=capture_output)
+
+    def npx(self, *args: str, capture_output: bool = True) -> CommandResult:
+        return self.get_manager().npx(*args, capture_output=capture_output)
+
+    def ci(self, *, capture_output: bool = True) -> CommandResult:
+        return self.get_manager().ci(capture_output=capture_output)
+
+    def package(self, name: str) -> Package:
+        return self.get_manager().package(name)
+
+    def resolve(self, name: str, asset: str | Path) -> Path:
+        return self.get_manager().resolve(name, asset)
+
+    def status(self) -> dict[str, Any]:
+        return self.get_manager().status()

flask_node/manager.py

@@ -0,0 +1,162 @@
+"""Application-local Node project lifecycle and dependency operations."""
+from dataclasses import dataclass
+import json
+from pathlib import Path
+from typing import Any
+
+from .exceptions import (ConfigurationError, DependencyConflictError, EnvironmentError,
+                         PackageNotFoundError, AssetResolutionError)
+from .package import Package, validate_name
+from .runner import CommandResult, CommandRunner
+
+
+@dataclass(frozen=True)
+class Dependency:
+    version: str
+    dev: bool = False
+
+
+class NodeManager:
+    def __init__(self, directory: Path, *, node_bin: str = "node", npm_bin: str = "npm",
+                 npx_bin: str = "npx", runner: CommandRunner | None = None):
+        self.directory = directory.resolve()
+        self.node_bin, self.npm_bin, self.npx_bin = node_bin, npm_bin, npx_bin
+        self.runner = runner if runner is not None else CommandRunner()
+        self._requirements: dict[str, Dependency] = {}
+
+    @property
+    def manifest_path(self) -> Path:
+        return self.directory / "package.json"
+
+    def _read_manifest(self) -> dict[str, Any]:
+        try:
+            data = json.loads(self.manifest_path.read_text(encoding="utf-8"))
+            if not isinstance(data, dict):
+                raise ValueError("manifest must be an object")
+            for section in ("dependencies", "devDependencies"):
+                dependencies = data.get(section, {})
+                if not isinstance(dependencies, dict) or not all(
+                    isinstance(k, str) and isinstance(v, str) for k, v in dependencies.items()
+                ):
+                    raise ValueError(f"{section} must map package names to strings")
+            return data
+        except (OSError, ValueError) as exc:
+            raise EnvironmentError(f"Cannot read {self.manifest_path}: {exc}") from exc
+
+    def _write_manifest(self, data: dict[str, Any]) -> None:
+        try:
+            self.manifest_path.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+        except OSError as exc:
+            raise EnvironmentError(f"Cannot write {self.manifest_path}: {exc}") from exc
+
+    def initialize(self) -> Path:
+        try:
+            self.directory.mkdir(parents=True, exist_ok=True)
+            # Exclusive creation preserves existing manifests, including concurrent init.
+            with self.manifest_path.open("x", encoding="utf-8") as stream:
+                json.dump({"private": True, "dependencies": {}, "devDependencies": {}}, stream, indent=2)
+                stream.write("\n")
+        except FileExistsError:
+            self._read_manifest()
+        except OSError as exc:
+            raise EnvironmentError(f"Cannot initialize {self.directory}: {exc}") from exc
+        return self.directory
+
+    def require(self, name: str, version: str = "*", *, dev: bool = False) -> None:
+        validate_name(name)
+        self._validate_version(version)
+        dependency = Dependency(version, dev)
+        previous = self._requirements.get(name)
+        if previous is not None and previous != dependency:
+            raise DependencyConflictError(f"Conflicting requirements for {name}: {previous} and {dependency}")
+        self._requirements[name] = dependency
+
+    @staticmethod
+    def _validate_version(version: str) -> None:
+        if not isinstance(version, str) or not version.strip() or "\x00" in version:
+            raise ConfigurationError("A dependency version must be a nonempty string.")
+
+    def _merge_requirements(self, data: dict[str, Any]) -> dict[str, Any]:
+        for name, dependency in self._requirements.items():
+            section = "devDependencies" if dependency.dev else "dependencies"
+            other = "dependencies" if dependency.dev else "devDependencies"
+            data.setdefault(other, {}).pop(name, None)
+            data.setdefault(section, {})[name] = dependency.version
+        return data
+
+    def install(self, name: str | None = None, version: str | None = None, *,
+                dev: bool = False, capture_output: bool = True) -> CommandResult:
+        if name is None and (version is not None or dev):
+            raise ConfigurationError("version/dev require a package name.")
+        if name is not None:
+            validate_name(name)
+            if version is not None:
+                self._validate_version(version)
+            required = self._requirements.get(name)
+            if required and (required.dev != dev or (version is not None and version != required.version)):
+                raise DependencyConflictError(f"Installation contradicts the declared requirement for {name}.")
+            if required:
+                version = required.version
+        self.initialize()
+        self._write_manifest(self._merge_requirements(self._read_manifest()))
+        args = ["install"]
+        if name is not None:
+            args.extend(["--save-dev" if dev else "--save-prod", "--",
+                         name + (f"@{version}" if version is not None else "")])
+        return self.npm(*args, capture_output=capture_output)
+
+    def uninstall(self, name: str, *, capture_output: bool = True) -> CommandResult:
+        validate_name(name)
+        if name in self._requirements:
+            raise DependencyConflictError(f"Cannot uninstall actively required package {name}.")
+        return self.npm("uninstall", "--", name, capture_output=capture_output)
+
+    def _check_environment(self) -> None:
+        if not self.manifest_path.is_file():
+            raise EnvironmentError("Node environment is not initialized. Run 'flask node init'.")
+        self._read_manifest()
+
+    def npm(self, *args: str, capture_output: bool = True) -> CommandResult:
+        self._check_environment()
+        return self.runner.run(self.npm_bin, args, cwd=self.directory, capture_output=capture_output)
+
+    def npx(self, *args: str, capture_output: bool = True) -> CommandResult:
+        self._check_environment()
+        return self.runner.run(self.npx_bin, args, cwd=self.directory, capture_output=capture_output)
+
+    def ci(self, *, capture_output: bool = True) -> CommandResult:
+        self._check_environment()
+        if not (self.directory / "package-lock.json").is_file():
+            raise EnvironmentError("npm ci requires package-lock.json. Run 'flask node install' first.")
+        data = self._read_manifest()
+        for name, dependency in self._requirements.items():
+            section = "devDependencies" if dependency.dev else "dependencies"
+            other = "dependencies" if dependency.dev else "devDependencies"
+            if data.get(section, {}).get(name) != dependency.version or name in data.get(other, {}):
+                raise DependencyConflictError(f"Manifest disagrees with the declared requirement for {name}.")
+        return self.npm("ci", capture_output=capture_output)
+
+    def package(self, name: str) -> Package:
+        validate_name(name)
+        modules = (self.directory / "node_modules").resolve()
+        root = (modules / name).resolve()
+        if not modules.is_relative_to(self.directory) or not root.is_relative_to(modules):
+            raise AssetResolutionError(f"Package {name} escapes the managed environment.")
+        try:
+            manifest = (root / "package.json").resolve()
+            if not manifest.is_relative_to(root):
+                raise AssetResolutionError(f"Package manifest escapes {name}.")
+            data = json.loads(manifest.read_text(encoding="utf-8"))
+            if not isinstance(data, dict) or not isinstance(data.get("version"), str):
+                raise ValueError("missing package version")
+        except (OSError, ValueError) as exc:
+            raise PackageNotFoundError(f"Package {name!r} is not installed or has an invalid manifest.") from exc
+        return Package(name, data["version"], root)
+
+    def resolve(self, name: str, asset: str | Path) -> Path:
+        return self.package(name).resolve(asset)
+
+    def status(self) -> dict[str, Any]:
+        return {"directory": str(self.directory), "initialized": self.manifest_path.is_file(),
+                "node": self.runner.locate(self.node_bin), "npm": self.runner.locate(self.npm_bin),
+                "npx": self.runner.locate(self.npx_bin)}

flask_node/package.py

@@ -0,0 +1,36 @@
+"""Safe access to installed package files, without asset delivery."""
+from dataclasses import dataclass
+from pathlib import Path, PureWindowsPath
+import re
+
+from .exceptions import AssetResolutionError, ConfigurationError
+
+
+_NAME = re.compile(r"(?:@[a-z0-9][a-z0-9._-]*/)?[a-z0-9][a-z0-9._-]*\Z")
+
+
+def validate_name(name: str) -> str:
+    if not isinstance(name, str) or not _NAME.fullmatch(name):
+        raise ConfigurationError(f"Invalid registry package name: {name!r}")
+    return name
+
+
+@dataclass(frozen=True)
+class Package:
+    name: str
+    version: str
+    root: Path
+
+    def resolve(self, asset: str | Path) -> Path:
+        value = str(asset)
+        relative = Path(value)
+        if (relative.is_absolute() or PureWindowsPath(value).drive or
+                "\\" in value or ".." in relative.parts):
+            raise AssetResolutionError(f"Unsafe asset path: {value!r}")
+        try:
+            target = (self.root / relative).resolve(strict=True)
+        except (OSError, RuntimeError) as exc:
+            raise AssetResolutionError(f"Asset {value!r} is unavailable in {self.name}") from exc
+        if not target.is_relative_to(self.root):
+            raise AssetResolutionError(f"Asset escapes package {self.name}: {value!r}")
+        return target

flask_node/runner.py

@@ -0,0 +1,44 @@
+"""The single subprocess boundary for managed commands."""
+from dataclasses import dataclass
+from pathlib import Path
+import shutil
+import subprocess
+
+from .exceptions import CommandExecutionError, ExecutableNotFoundError
+
+
+@dataclass(frozen=True)
+class CommandResult:
+    args: tuple[str, ...]
+    returncode: int
+    stdout: str | None = None
+    stderr: str | None = None
+
+
+class CommandRunner:
+    def locate(self, executable: str) -> str | None:
+        return shutil.which(executable)
+
+    def run(self, executable: str, args: tuple[str, ...], *, cwd: Path,
+            capture_output: bool = True) -> CommandResult:
+        located = self.locate(executable)
+        if located is None:
+            raise ExecutableNotFoundError(
+                f"Executable {executable!r} was not found. Install Node.js/npm or configure its path."
+            )
+        command = (located, *args)
+        try:
+            result = subprocess.run(command, cwd=cwd, shell=False, check=False,
+                                    text=True, capture_output=capture_output)
+        except FileNotFoundError as exc:
+            raise ExecutableNotFoundError(f"Cannot launch {executable!r}: {exc}") from exc
+        except OSError as exc:
+            raise CommandExecutionError(str(exc), args=command, cwd=str(cwd)) from exc
+        if result.returncode:
+            detail = (result.stderr or result.stdout or "").strip()
+            raise CommandExecutionError(
+                f"{executable} exited with status {result.returncode}" +
+                (f": {detail}" if detail else "."), args=command, cwd=str(cwd),
+                returncode=result.returncode, stdout=result.stdout, stderr=result.stderr,
+            )
+        return CommandResult(command, result.returncode, result.stdout, result.stderr)

flask_node-0.1.0.dist-info/METADATA

@@ -0,0 +1,185 @@
+Metadata-Version: 2.4
+Name: Flask-Node
+Version: 0.1.0
+Summary: Isolated Node/npm infrastructure for Flask extensions
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Flask<4,>=2.2
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# Flask-Node
+
+Flask-Node manages an isolated Node/npm project for Flask applications and
+extensions. It contains no JavaScript library integrations, bundler, asset
+server, or frontend framework.
+
+Requires Python 3.10+ and Flask 2.2–3.x. Install Node.js (including npm/npx)
+separately when executing commands; importing and initializing the Flask
+extension does not require it.
+
+```bash
+pip install Flask-Node
+```
+
+## Application setup
+
+```python
+from flask import Flask
+from flask_node import Node
+
+node = Node()
+
+def create_app():
+    app = Flask(__name__)
+    node.init_app(app)
+    return app
+```
+
+`Node(app)` is also supported. `init_app()` registers defaults and the CLI,
+without creating directories or launching commands. Each application owns a
+separate `NodeManager` in `app.extensions["node"]`; a shared `Node` facade uses
+the current application context. `node.get_manager(app)` gives explicit access
+outside a context. Duplicate registration raises `ConfigurationError`.
+
+## Configuration
+
+| Setting | Default | Meaning |
+| --- | --- | --- |
+| `NODE_DIR` | `.node` | Relative to `app.root_path`, or an absolute path |
+| `NODE_BIN` | `node` | Node executable name or path |
+| `NODE_NPM_BIN` | `npm` | npm executable name or path |
+| `NODE_NPX_BIN` | `npx` | npx executable name or path |
+
+Configure before calling `init_app()`. Configuration is captured per app.
+For a directory beside an application package, configure an absolute project
+path. No behavior depends on the shell's current directory.
+
+## Lifecycle and dependencies
+
+```python
+with app.app_context():
+    node.require("example", version="^1")
+    node.require("@scope/build-tool", version="^2", dev=True)
+    node.initialize()
+    node.install()
+    node.install("another-package", version="^3")
+    node.uninstall("another-package")
+```
+
+`require()` only records an in-memory declaration. Consumer extensions may call
+it during application setup. It creates no files and does not check or install
+packages. Identical declarations are idempotent; differing versions or dependency
+sections raise `DependencyConflictError`. Version declarations are compared as
+strings; Flask-Node does not solve semver ranges.
+
+`initialize()` creates `.node/package.json` with `private: true` and empty
+`dependencies` / `devDependencies`. It preserves an existing valid manifest
+without rewriting it. Invalid manifests fail clearly. npm creates the lockfile
+and installed modules later:
+
+```text
+.node/
+    package.json
+    package-lock.json
+    node_modules/
+```
+
+`install()` initializes if necessary, merges active declarations into the
+manifest, preserves unrelated fields and dependencies, and runs `npm install`.
+Declarations take precedence over persisted entries for the same package.
+`install(name, version=None, dev=False)` additionally installs a registry package;
+without a version, npm chooses it unless an active declaration supplies one.
+Conflicting explicit options fail before installation. Uninstalling an actively
+required package is rejected. npm failures may leave manifest changes or partial
+installation artifacts; operations are not transactional.
+
+`ci()` requires `package-lock.json` and declarations matching the manifest, then
+runs `npm ci` without rewriting the manifest. npm validates lockfile consistency.
+Commit `.node/package.json` and `.node/package-lock.json` for reproducible builds;
+ignore `.node/node_modules/`.
+
+## Commands and diagnostics
+
+```python
+with app.app_context():
+    result = node.npm("run", "custom-script")
+    result = node.npx("some-tool", "--help", capture_output=False)
+    print(node.status())
+```
+
+Raw commands require an initialized environment and run with its directory as
+`cwd`. Arguments are passed individually with `shell=False`. Python calls capture
+output by default; use `capture_output=False` to inherit terminal streams.
+`CommandResult` exposes `args`, `returncode`, `stdout`, and `stderr`.
+
+`status()` reports the directory, manifest presence, and executable locations
+(or `None`). It launches no processes and does not validate executable versions.
+Missing executables raise `ExecutableNotFoundError`; nonzero exits and other
+launch failures raise `CommandExecutionError`, which retains `command`, `cwd`,
+`returncode`, `stdout`, and `stderr`. All public errors derive from `NodeError`.
+
+npm/npx may access the network and run package scripts. The managed working
+directory is not a process sandbox; invoked tools can write elsewhere.
+
+## Flask CLI
+
+```bash
+flask --app your_app node init
+flask --app your_app node install
+flask --app your_app node install example --version '^1' --dev
+flask --app your_app node uninstall example
+flask --app your_app node npm -- run custom-script --flag
+flask --app your_app node npx -- some-tool --help
+flask --app your_app node ci
+flask --app your_app node status
+```
+
+CLI commands use the same Python operations, stream subprocess output, and
+report extension errors with a nonzero exit status. `--` separates forwarding
+arguments from Click's own options.
+
+## Installed assets and extension consumers
+
+```python
+manager = app.extensions["node"]
+manager.require("example", "^1")  # Safe during consumer init_app().
+
+# After an explicit installation step:
+asset = manager.resolve("example", "dist/example.js")
+package = manager.package("example")
+assert package.resolve("dist/example.js") == asset
+print(package.name, package.version, package.root)
+```
+
+The consumer must initialize Flask-Node first. It owns its library-specific
+configuration, rendering, asset copying/serving, and build/watch commands.
+Flask-Node only declares/installs dependencies, executes commands, and locates
+files. No registration protocol is needed.
+
+Package lookup supports ordinary and scoped registry names. Asset lookup returns
+an existing `Path`; absolute paths, parent traversal, Windows-style paths, and
+symlinks escaping the package or managed environment are rejected. Externally
+linked packages are intentionally unsupported. Missing or malformed installed
+packages raise `PackageNotFoundError`; unsafe or missing assets raise
+`AssetResolutionError`. This is filesystem path validation, not protection
+against concurrent malicious filesystem changes.
+
+## Development
+
+```bash
+python -m venv .venv
+.venv/bin/python -m pip install -e '.[test]' build
+.venv/bin/python -m pytest
+.venv/bin/python -m build
+```
+
+Tests inject/mock the runner and subprocess boundary. They never download npm
+packages or require Node. A custom runner can be supplied to `Node(runner=...)`
+or `NodeManager(..., runner=...)` for testing. This dependency injection is not a
+consumer plugin protocol.
+
+Inspired by [Flask-Tailwind-Manager](https://github.com/SebaSalinass/flask-tailwind-manager).

flask_node-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+flask_node/__init__.py,sha256=gRPSFdjat-Lc5qWFfuTENhxKYRRSwjvZ9unjWTlVBzc,702
+flask_node/cli.py,sha256=3v8v443_E1Ibp5COLtL22QSFPanlxG7_5XQkmgPv4Dw,2132
+flask_node/exceptions.py,sha256=QtPIEL0YphtdgPxVf6U8OFy379skumWS3ProIYEHsfw,841
+flask_node/extension.py,sha256=hmGAZoNK3YCEUSArzz2Yp31F-0vBwx6AIP8pVs3QTGQ,3528
+flask_node/manager.py,sha256=RbnAv8rGkF8GRUmrS8S_FfHAk200PF5UDpiuus9W37o,8199
+flask_node/package.py,sha256=D0eo7WiQ8aCWr889t_bOzzwIBjTRL-KFMyeibYbTPvs,1270
+flask_node/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flask_node/runner.py,sha256=3bIhrgf0_S288QhdQ_x2OaC4Z77BZAvWjjtI4j1BN68,1792
+flask_node-0.1.0.dist-info/licenses/LICENSE,sha256=eb9NV436hjrM4Ra_SC_Vl1hpk5tYtXojbOi4tmgJ3CI,1074
+flask_node-0.1.0.dist-info/METADATA,sha256=g2mdmeqlnFRKh1AyweHuZQCtANmiPHp4KuuacFpaYbM,7062
+flask_node-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+flask_node-0.1.0.dist-info/top_level.txt,sha256=hI1qQ_O5mRkLX0gHmrmf7dQQqWH5ngGhDZG4RlW1he4,11
+flask_node-0.1.0.dist-info/RECORD,,

flask_node-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flask_node-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sebastian Salinas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flask_node-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flask_node