搜尋套件、儲存庫與 APP 分類

套件詳情v0.2.1

scoped_deps

一個簡單的 Dart 庫,用於管理基於 dart:async 中 Zones 的作用域依賴項。

AndroidiOSLinuxmacOSWebWindows
近 30 天下載
11.8萬
喜歡數
9
Pub 分數
160

安裝套件

flutter pub add scoped_deps

套件介紹

根據套件公開資料產生的選型評估,僅供參考。

Scoped_deps 是一個輕量級的 Dart 庫,使用 dart:async 的 Zones 管理作用域依賴。它允許開發者在應用的特定部分建立隔離的依賴上下文,確保依賴僅在預期位置可存取。這透過避免全域狀態,促進更乾淨的程式碼組織與更好的可測試性。該庫與所有平台上的 Flutter 應用無縫整合,提供簡單的 API 用於在作用域 Zone 內註冊和取得依賴。

適用情境

  • 管理UI特定的依賴項
  • 獨立測試組件
  • 避免全域狀態污染
  • 建立模組化的應用區段
  • 簡化大型應用中的依賴注入

主要特色

  • 基於區域的依賴作用範圍
  • 最小 API 表面
  • 跨平台支援
  • 與 Flutter 的輕鬆整合
  • 無執行時間開銷

適合對象

  • 尋求輕量級依賴注入的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 項

原始碼儲存庫

使用此套件的專案

暫無相關資料。

所在榜單