パッケージ、リポジトリ、アプリカテゴリを検索

パッケージ詳細v0.2.1

scoped_deps

dart:async の Zones をベースにしたスコープ付き依存関係を管理するシンプルな Dart ライブラリ。

AndroidiOSLinuxmacOSWebWindows
30日間ダウンロード
11.8万
いいね数
9
Pub ポイント
160

パッケージをインストール

flutter pub add scoped_deps

パッケージ概要

公開情報に基づく選定ガイドです。参考としてご利用ください。

Scoped_deps は、dart:async の Zones を使用してスコープ付きの依存関係を管理する軽量な Dart ライブラリです。開発者がアプリ内の特定の部分に分離された依存関係コンテキストを作成できるようにし、依存関係が意図した場所でのみアクセス可能になることを保証します。これにより、グローバル状態を避けることでコードの整理がしやすくなり、テストのしやすさも向上します。このライブラリはすべてのプラットフォームで Flutter アプリとシームレスに統合され、スコープ付きゾーン内で依存関係の登録と取得を行うためのシンプルな API を提供しています。

用途

  • UI 固有の依存関係の管理
  • コンポーネントを独立してテストする
  • グローバル状態の汚染を回避する
  • モジュール化されたアプリケーションセクションの作成
  • 大規模アプリにおける依存関係の挿入を簡素化する

主な機能

  • ゾーンベースの依存関係スコープ
  • 最小限の API サーフェス
  • クロスプラットフォーム対応
  • Flutter との簡単な統合
  • 実行時オーバーヘッドなし

適している対象

  • 軽量なDIを求めるFlutter開発者
  • モジュールアーキテクチャを持つアプリ
  • 明確な依存関係の境界が必要なチーム
  • テスト駆動開発ワークフロー
  • 重いフレームワークを避けるプロジェクト

注意事項

  • 複雑な依存関係グラフには適していません
  • Zones の理解が必要です
  • 熟練したライブラリと比べてドキュメントが限られている
  • 小規模から中規模のアプリに最適
  • 既存の依存関係パターンの再設計が必要になる可能性があります

元の README

関連するソースリポジトリの README 原文のスナップショットです。最新の内容はリポジトリをご覧ください。

Scoped Deps

A simple dependency injection library built on Zones.

read resolves bindings from an internal registration table that tracks each [Zone] established by this library, so it is not fooled by [Zone]'s inherited [] behavior (which can copy a parent's [ScopedRef] into a middle zone and mask a child's override). For subprocess or other IO that may resume outside that zone, combine with [Zone.bindUnaryCallback] (or related APIs) when registering native callbacks.

Quick Start

import 'package:scoped_deps/scoped_deps.dart';

final value = create(() => 42);

void main() {
  runScoped(scopeA, values: {value});
}

void scopeA() {
  print(read(value)); // 42
  runScoped(scopeB, values: {value.overrideWith(() => 0)});
}

void scopeB() {
  print(read(value)); // 0
}

Recommended: hide read behind a getter

Calling read(valueProvider) at every call site works, but it spreads ScopedRefs through code that shouldn't need to know they exist. Pair each ScopedRef with a top-level getter instead, and let the rest of the app read it like an ordinary variable:

final valueProvider = create(() => 42);
int get value => read(valueProvider);
void main() {
  runScoped(() {
    print(value); // 42
  }, values: {valueProvider});
}

Anything that reads value — no matter how deeply nested — resolves against whichever scope is active when it runs. Callers never import ScopedRef or call read directly, which also makes the pattern straightforward to test (see Testing below).

API

  • create(() => value) — declare a ScopedRef<T>.
  • read(ref, {orElse}) — resolve ref in the current scope; throws a StateError (or calls orElse) if no scope provides it.
  • isRegistered(ref) — check whether ref is bound in the current scope, without the StateError/orElse path.
  • runScoped(body, {values}) — run body in a scope that provides values.
  • runMergedScoped(body, {override, includeIfAbsent}) — run body in a scope forked from the current one. override replaces the current binding for those refs; includeIfAbsent adds a binding only for refs the current scope chain doesn't already define.
  • runMergedScopedFuture(body, {override, includeIfAbsent, zoneSpecification}) — like runMergedScoped, but requires an explicitly async body and accepts an optional zoneSpecification (e.g. to intercept print). override / includeIfAbsent survive await in runMergedScoped too — reach for this variant when you want the stricter async signature or need zoneSpecification, not because bindings would otherwise be lost.
  • runScopedGuarded(body, {onError, values}) — like runScoped, but uncaught errors are routed to onError instead of thrown.
  • ref.overrideWith(() => other) — a ref with the same identity as ref but a different value factory, used to substitute a value for a nested scope (or in a test).

Testing

Bindings live on the Zone, so they don't exist until something establishes a scope — code under test has to run inside a runScoped / runMergedScoped call that provides whatever it reads. A setUp can't do this on its own: it runs to completion before the test body starts, so any scope it forks is already gone by the time your test executes. Wrap the test body itself:

final valueProvider = create(() => 42);
int get value => read(valueProvider);

int doubleValue() => value * 2;

test('doubleValue uses the overridden value', () {
  runScoped(() {
    expect(doubleValue(), equals(20));
  }, values: {valueProvider.overrideWith(() => 10)});
});

The override applies no matter how deep the call chain is — doubleValue() never has to know it's under test. The same works for async code under test; the override stays bound across every await:

Future<int> asyncDoubleValue() async {
  await Future<void>.delayed(Duration.zero);
  return value * 2;
}

test('asyncDoubleValue uses the overridden value', () async {
  await runScoped(() async {
    expect(await asyncDoubleValue(), equals(20));
  }, values: {valueProvider.overrideWith(() => 10)});
});

Reach for runMergedScopedFuture instead when a test also needs a zoneSpecification — for example, to capture print output for the duration of the test rather than letting it hit the console.

カテゴリー

依存関係

依存関係一覧 1 件

ソースリポジトリ

このパッケージを使用しているプロジェクト

データはまだありません。

ランキング