resetDependencies - greydragon888/real-router GitHub Wiki

getDependenciesApi().reset

1. Overview

  • What it does: Removes all dependencies, replacing the container with a fresh empty object (Object.create(null)). Idempotent -- safe to call multiple times.
  • When to use:
    • For complete dependency cleanup
    • In tests for isolation between test cases
    • For complete dependency reinitialization

2. Signature

import { createRouter } from "@real-router/core";
import { getDependenciesApi } from "@real-router/core/api";

const router = createRouter<Dependencies>(routes, options, dependencies);
const depsApi = getDependenciesApi(router);

depsApi.reset(): void

Usage Examples

import { createRouter } from "@real-router/core";
import { getDependenciesApi } from "@real-router/core/api";

interface AppDependencies {
  api: ApiClient;
  analytics: Analytics;
  store: Store;
}

const router = createRouter<AppDependencies>(
  routes,
  {},
  {
    api: new ApiClient(),
    analytics: new Analytics(),
    store: new Store(),
  },
);

const depsApi = getDependenciesApi(router);

// Complete cleanup
depsApi.reset();
console.log(depsApi.getAll()); // {}

// In tests -- isolation
afterEach(() => {
  depsApi.reset();
});

// Complete reinitialization pattern
depsApi.reset();
depsApi.set("api", newApiClient);
depsApi.set("analytics", newAnalytics);
depsApi.set("store", newStore);

3. Parameters

Method takes no parameters.

4. Return Value

  • Type: void

5. Side Effects

  • Removes all dependencies: Internal container is replaced with a fresh empty object (Object.create(null))
  • Effect on other methods:
    • depsApi.getAll() returns {}
    • depsApi.has(key) returns false for all keys
    • depsApi.get(key) throws ReferenceError for all keys

6. Possible Errors

Condition Error Type Code
Router disposed RouterError ROUTER_DISPOSED

Idempotent -- does not throw when called on an already-empty container.

Error Example

router.dispose();
const depsApi = getDependenciesApi(router);

depsApi.reset();
// RouterError: ROUTER_DISPOSED

7. Related Methods

Method When to use
getDependenciesApi().remove Remove single dependency
getDependenciesApi().set Set after reset
getDependenciesApi().setAll Batch set after reset
getDependenciesApi().getAll Check reset result

Comparison with remove

const depsApi = getDependenciesApi(router);

// remove -- removes one dependency at a time
depsApi.remove("service1");
depsApi.remove("service2");

// reset -- removes all at once
depsApi.reset();

8. Behavior

Main Scenarios

  • Removes all dependencies: getAll() returns {}
  • Idempotency: Safe to call multiple times, including on empty container
  • Throws after dispose: RouterError(ROUTER_DISPOSED)

From Tests

import { createRouter } from "@real-router/core";
import { getDependenciesApi } from "@real-router/core/api";

interface Deps {
  foo?: number;
  bar?: string;
}

const router = createRouter<Deps>([], {}, {});
const depsApi = getDependenciesApi(router);

// Removes all dependencies
depsApi.setAll({ foo: 5, bar: "test" });
depsApi.reset();

const all = depsApi.getAll();
expect(all).toStrictEqual({});

// Can set dependencies after reset
depsApi.reset();
depsApi.set("foo", 42);
expect(depsApi.get("foo")).toBe(42);

has Returns false After Reset

depsApi.setAll({ foo: 1, bar: "value" });
depsApi.reset();

expect(depsApi.has("foo")).toBe(false);
expect(depsApi.has("bar")).toBe(false);

get Throws After Reset

depsApi.setAll({ foo: 1, bar: "test" });
depsApi.reset();

// All previous dependencies throw ReferenceError
expect(() => depsApi.get("foo")).toThrowError(ReferenceError);
expect(() => depsApi.get("bar")).toThrowError(ReferenceError);

Idempotency

depsApi.setAll({ foo: 1, bar: "test" });

// First reset
depsApi.reset();
expect(depsApi.getAll()).toStrictEqual({});

// Second reset -- does not throw
expect(() => depsApi.reset()).not.toThrowError();
expect(depsApi.getAll()).toStrictEqual({});

// Third reset -- still safe
expect(() => depsApi.reset()).not.toThrowError();

Safe on Empty Container

depsApi.reset(); // Already empty

// Does not throw
expect(() => depsApi.reset()).not.toThrowError();
expect(depsApi.getAll()).toStrictEqual({});

Special Keys

depsApi.set("", "empty");
depsApi.set("api:v2", "colon");
depsApi.set("用户", "unicode");

depsApi.reset();

expect(depsApi.has("")).toBe(false);
expect(depsApi.has("api:v2")).toBe(false);
expect(depsApi.has("用户")).toBe(false);

Falsy Values Are Also Removed

depsApi.set("foo", 0);
depsApi.set("bar", null);
depsApi.set("baz", false);

depsApi.reset();

expect(depsApi.has("foo")).toBe(false);
expect(depsApi.has("bar")).toBe(false);
expect(depsApi.has("baz")).toBe(false);

Complete Reinitialization Pattern

// Initial setup
depsApi.setAll({ foo: 1, bar: "old" });

// Complete reinitialization
depsApi.reset();
depsApi.set("baz", "new1");
depsApi.set("qux", "new2");

// Old dependencies removed
expect(depsApi.has("foo")).toBe(false);
expect(depsApi.has("bar")).toBe(false);

// New dependencies set
expect(depsApi.get("baz")).toBe("new1");
expect(depsApi.get("qux")).toBe("new2");

Test Isolation Pattern

const depsApi = getDependenciesApi(router);

// Test 1
depsApi.set("testDep1", "value1");
expect(depsApi.has("testDep1")).toBe(true);

// Cleanup between tests
depsApi.reset();

// Test 2 -- does not see dependencies from test 1
expect(depsApi.has("testDep1")).toBe(false);

depsApi.set("testDep2", "value2");
expect(depsApi.has("testDep2")).toBe(true);

// Cleanup
depsApi.reset();
expect(depsApi.has("testDep2")).toBe(false);

Edge Cases

  • Empty container: Safe to call
  • Multiple calls: Idempotent
  • Special keys: "", Unicode, special characters -- all removed
  • Falsy values: 0, null, false -- all removed
  • After reset: Can set new dependencies

Guarantees

  • Returns void
  • Idempotency -- safe to call on empty container
  • Throws RouterError(ROUTER_DISPOSED) if router is disposed
  • All dependencies removed (including falsy values)
  • All special keys removed (Unicode, empty string, special characters)
  • Can set new dependencies after reset
  • Integration with has, get, getAll

9. Migration from router5

Before (router5) After (real-router)
router.resetDependencies() getDependenciesApi(router).reset() 
// Before (router5)
router.resetDependencies();

// After (real-router)
import { getDependenciesApi } from "@real-router/core/api";

const depsApi = getDependenciesApi(router);
depsApi.reset();

Note: the return type changed from Router (fluent interface) to void.

Real Router - A simple, powerful, view-agnostic, modular and extensible router

GitHub | npm | Issues

⚠️ **GitHub.com Fallback** ⚠️