Dependencies

A component's merged secondary assets (from the nested Dependencies classes).

Holds resolved entries:

• a local file (declared with PathLike or a resolvable string) - resolved to Path
• URLs (plain strings) - unchanged
• Script/Style objects - unchanged
• Pre-rendered tags (__html__) - unchanged

The entry's type is what tells the emission step what to do with it (inline the file content, emit a src/href tag, or output the tag verbatim; see emission.py).

Attributes

• js tuple[Any, ...] - JS entries, base classes' entries first, then the class's own, de-duplicated.
• css Mapping[str, tuple[Any, ...]] - CSS entries per media type (``"all"``, ``"print"``, ...), same ordering per list.

js: tuple[Any, ...]

css: Mapping[str, tuple[Any, ...]]

Shared base of :class:Script and :class:Style.

Holds either inline content or a url, never both; rendering raises when neither or both are set.

content: str | None

url: str | None

attrs: dict[str, str | bool]

kind: DependencyKind

origin_class_id: str | None

render() -> SafeString

render_json() -> dict[str, str | dict[str, str | bool]]

One "this component instance rendered" note, collected during a render.

The dependencies extension appends one of these to the render-scoped CitryContext.extra per component render, and the notes bubble up to the root as nested renders are consumed. At serialize time the collected records are resolved into the actual Script/Style tags. The exact class is retained until serialization so hot replacement cannot mix a rendered old body with a new class's assets; heavy content lives in the cache.

class_id: str

component_id: str

js_vars_hash: str | None

css_vars_hash: str | None

component_class: type[Component] | None

One <script> tag.

With url set, renders <script src="...">; otherwise renders the content inline as <script>...</script>.

Example::

Script(content="console.log('hi');", attrs={"type": "module"}, wrap=False)
# <script type="module">console.log('hi');</script>

wrap: bool

(function() {
console.log('hi');
})();

to_json() -> dict[str, Any]

from_json(data: dict[str, Any]) -> Script

One stylesheet tag.

With url set, renders <link rel="stylesheet" href="..."/>; otherwise renders the content inline as <style>...</style>.

Example::

Style(url="/static/print.css", attrs={"media": "print"})
# <link media="print" rel="stylesheet" href="/static/print.css"/>

to_json() -> dict[str, Any]

from_json(data: dict[str, Any]) -> Style

render() -> SafeString

The built-in extension owning the Dependencies secondary-asset class.

The loading half reads each component or reusable definition base's preserved Dependencies declaration, resolves and merges declarations lazily in :meth:resolve, and drops a class's derived state when its files are reset or its final registry alias is removed.

The emission half (docs/design/dependencies.md): records each component render (on_component_data), bubbles the records up as nested renders are consumed (on_render_context_merge), and at serialize time turns them into <script>/<style>/<link> tags placed into the page (on_serialize, implemented in emission.py).

on_component_unregistered(ctx: OnComponentUnregisteredContext) -> None

on_files_reset(ctx: OnFilesResetContext) -> None

on_component_data(ctx: OnComponentDataContext) -> None

on_render_context_merge(ctx: OnRenderContextMergeContext) -> None

export_render_cache(ctx: OnRenderCacheExportContext) -> dict[str, object]

stage_render_cache(ctx: OnRenderCacheStageContext) -> StagedRenderCacheContribution

on_serialize(ctx: OnSerializeContext) -> str | None

urls: list[URLRoute]

resolve(comp_cls: type[Component]) -> CitryDependencies

Context for the on_dependencies hook, owned by the dependencies extension (not a "core" hook: any extension that defines an on_dependencies method receives it, via the manager's emit).

Fires at serialize time with the final, deduplicated tag lists (possibly empty), just before they are rendered into the page. Mutate the lists in place to add, remove, or reorder entries.

citry: Citry

scripts: list[Dependency]

styles: list[Dependency]

context: CitryContext

strategy: str

before_manifest: list[Dependency]

The merged secondary assets of a component class.

Routes through the class's Citry instance to its built-in dependencies extension. Users reach this through Card.get_dependencies().