@burojs/context 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+//#region src/types/permissions.d.ts
 type PermissionStatus = 'loading' | 'ready' | 'error';
 /**
  * Permission resolver returned by user's permissions slice.
@@ -7,39 +8,44 @@ type PermissionStatus = 'loading' | 'ready' | 'error';
  *   ready: normal evaluation
  */
 interface PermissionMap {
-    status: PermissionStatus;
-    can: (action: string, resource: string, record?: unknown) => boolean;
-    reason: (action: string, resource: string, record?: unknown) => string | undefined;
+  status: PermissionStatus;
+  can: (action: string, resource: string, record?: unknown) => boolean;
+  reason: (action: string, resource: string, record?: unknown) => string | undefined;
 }
-
+//#endregion
+//#region src/types/slice.d.ts
 type SliceKind = 'static' | 'fromAuth' | 'picker' | 'async';
 /**
  * Common shape for all slice definitions.
  * Specific kinds extend this with kind-specific fields (defined in slices/*.ts).
  */
 interface SliceDefinition<TName extends string = string, TValue = unknown> {
-    name: TName;
-    kind: SliceKind;
-    deps: string[];
-    /** Phantom — for type inference of slice value types. */
-    __valueType?: TValue;
-}
-
+  name: TName;
+  kind: SliceKind;
+  deps: string[];
+  /** Phantom — for type inference of slice value types. */
+  __valueType?: TValue;
+}
+//#endregion
+//#region src/types/store.d.ts
 interface Store<TState extends Record<string, unknown>> {
-    snapshot: () => TState;
-    setSlice: <K extends keyof TState>(key: K, value: TState[K]) => void;
-    subscribe: (fn: () => void, selector?: (state: TState) => unknown) => () => void;
+  snapshot: () => TState;
+  setSlice: <K extends keyof TState>(key: K, value: TState[K]) => void;
+  subscribe: (fn: () => void, selector?: (state: TState) => unknown) => () => void;
 }
-
+//#endregion
+//#region src/atom.d.ts
 interface Atom<T> {
-    get: () => T;
-    set: (value: T) => void;
-    subscribe: (fn: () => void) => () => void;
+  get: () => T;
+  set: (value: T) => void;
+  subscribe: (fn: () => void) => () => void;
 }
 declare function createAtom<T>(initial: T): Atom<T>;
-
+//#endregion
+//#region src/store.d.ts
 declare function createStore<TState extends Record<string, unknown>>(initial: TState): Store<TState>;
-
+//#endregion
+//#region src/tracked-deps.d.ts
 /**
  * Proxy-based read tracking. The selector function reads from a Proxy
  * wrapping the target; every property access is recorded with dotted-path keys.
@@ -48,42 +54,46 @@ declare function createStore<TState extends Record<string, unknown>>(initial: TS
  * enabling point-wise re-invocation only when relevant slices change.
  */
 interface TrackedReadResult<T> {
-    result: T;
-    deps: Set<string>;
+  result: T;
+  deps: Set<string>;
 }
 declare function trackReads<TCtx, TResult>(ctx: TCtx, selector: (c: TCtx) => TResult): TrackedReadResult<TResult>;
-
+//#endregion
+//#region src/dag.d.ts
 interface DagNode {
-    name: string;
-    deps: string[];
+  name: string;
+  deps: string[];
 }
 /**
  * Kahn-style topological sort with cycle detection.
  * Throws on cycles (with path) and on missing dependencies.
  */
 declare function topoSort<N extends DagNode>(nodes: N[]): N[];
-
+//#endregion
+//#region src/slices/static.d.ts
 interface StaticSliceDefinition<TName extends string, TValue> extends SliceDefinition<TName, TValue> {
-    kind: 'static';
-    value: () => TValue;
+  kind: 'static';
+  value: () => TValue;
 }
 interface StaticSliceConfig<TValue> {
-    value: TValue | (() => TValue);
+  value: TValue | (() => TValue);
 }
 declare function defineStaticSlice<TName extends string, TValue>(name: TName, config: StaticSliceConfig<TValue>): StaticSliceDefinition<TName, TValue>;
-
+//#endregion
+//#region src/slices/from-auth.d.ts
 type AuthInvalidationEvent = 'login' | 'logout' | 'refresh';
 interface FromAuthSliceDefinition<TName extends string, TValue> extends SliceDefinition<TName, TValue> {
-    kind: 'fromAuth';
-    extract: (rawAuthUser: unknown) => TValue;
-    invalidateOn: AuthInvalidationEvent[];
+  kind: 'fromAuth';
+  extract: (rawAuthUser: unknown) => TValue;
+  invalidateOn: AuthInvalidationEvent[];
 }
 interface FromAuthSliceConfig<TValue> {
-    extract: (rawAuthUser: never) => TValue;
-    invalidateOn?: AuthInvalidationEvent[];
+  extract: (rawAuthUser: never) => TValue;
+  invalidateOn?: AuthInvalidationEvent[];
 }
 declare function defineFromAuthSlice<TName extends string, TValue>(name: TName, config: FromAuthSliceConfig<TValue>): FromAuthSliceDefinition<TName, TValue>;
-
+//#endregion
+//#region src/slices/picker.d.ts
 type PickerPersistMode = 'localStorage' | 'sessionStorage' | 'url';
 /**
  * Picker target — minimal contract. Real ResourceDef from @burojs/core
@@ -102,62 +112,64 @@ type PickerPersistMode = 'localStorage' | 'sessionStorage' | 'url';
  *   Resolver emits a dev-warning if target has those set.
  */
 interface PickerSliceDefinition<TName extends string, TValue> extends SliceDefinition<TName, TValue> {
-    kind: 'picker';
-    resource: () => unknown;
-    filter?: (ctx: never) => Record<string, unknown>;
-    resetWhen?: string[];
-    persist?: PickerPersistMode;
-    required: boolean;
+  kind: 'picker';
+  resource: () => unknown;
+  filter?: (ctx: never) => Record<string, unknown>;
+  resetWhen?: string[];
+  persist?: PickerPersistMode;
+  required: boolean;
 }
 interface PickerSliceConfig {
-    resource: () => unknown;
-    dependsOn?: string[];
-    filter?: (ctx: never) => Record<string, unknown>;
-    resetWhen?: string[];
-    persist?: PickerPersistMode;
-    required?: boolean;
+  resource: () => unknown;
+  dependsOn?: string[];
+  filter?: (ctx: never) => Record<string, unknown>;
+  resetWhen?: string[];
+  persist?: PickerPersistMode;
+  required?: boolean;
 }
 declare function definePickerSlice<TName extends string, TValue = unknown>(name: TName, config: PickerSliceConfig): PickerSliceDefinition<TName, TValue>;
-
+//#endregion
+//#region src/slices/async.d.ts
 interface AsyncSliceDefinition<TName extends string, TValue> extends SliceDefinition<TName, TValue> {
-    kind: 'async';
-    fetch: (ctx: never) => Promise<TValue>;
-    cacheKey?: (ctx: never) => string;
-    staleTime: number;
+  kind: 'async';
+  fetch: (ctx: never) => Promise<TValue>;
+  cacheKey?: (ctx: never) => string;
+  staleTime: number;
 }
 interface AsyncSliceConfig<TValue> {
-    dependsOn?: string[];
-    fetch: (ctx: never) => Promise<TValue>;
-    cacheKey?: (ctx: never) => string;
-    /** ms; 0 = always refetch on invalidation */
-    staleTime?: number;
+  dependsOn?: string[];
+  fetch: (ctx: never) => Promise<TValue>;
+  cacheKey?: (ctx: never) => string;
+  /** ms; 0 = always refetch on invalidation */
+  staleTime?: number;
 }
 declare function defineAsyncSlice<TName extends string, TValue>(name: TName, config: AsyncSliceConfig<TValue>): AsyncSliceDefinition<TName, TValue>;
-
+//#endregion
+//#region src/define-context-slices.d.ts
 interface SliceBuilder {
-    static: <TValue>(config: StaticSliceConfig<TValue>) => StaticSliceDefinition<string, TValue>;
-    fromAuth: <TValue>(config: FromAuthSliceConfig<TValue>) => FromAuthSliceDefinition<string, TValue>;
-    picker: <TValue = unknown>(config: PickerSliceConfig) => PickerSliceDefinition<string, TValue>;
-    async: <TValue>(config: AsyncSliceConfig<TValue>) => AsyncSliceDefinition<string, TValue>;
+  static: <TValue>(config: StaticSliceConfig<TValue>) => StaticSliceDefinition<string, TValue>;
+  fromAuth: <TValue>(config: FromAuthSliceConfig<TValue>) => FromAuthSliceDefinition<string, TValue>;
+  picker: <TValue = unknown>(config: PickerSliceConfig) => PickerSliceDefinition<string, TValue>;
+  async: <TValue>(config: AsyncSliceConfig<TValue>) => AsyncSliceDefinition<string, TValue>;
 }
 declare function defineContextSlices<T extends Record<string, SliceDefinition>>(factory: (s: SliceBuilder) => T): T;
-
+//#endregion
+//#region src/resolver.d.ts
 interface Resolver<TSlices extends Record<string, SliceDefinition>> {
-    boot: () => Promise<void>;
-    snapshot: () => {
-        [K in keyof TSlices]: unknown;
-    };
-    setSlice: <K extends keyof TSlices>(key: K, value: unknown) => void;
-    subscribe: (fn: () => void, selector?: (s: never) => unknown) => () => void;
-    feedAuth: (rawAuthUser: unknown) => void;
-    flushAsync: () => Promise<void>;
+  boot: () => Promise<void>;
+  snapshot: () => { [K in keyof TSlices]: unknown; };
+  setSlice: <K extends keyof TSlices>(key: K, value: unknown) => void;
+  subscribe: (fn: () => void, selector?: (s: never) => unknown) => () => void;
+  feedAuth: (rawAuthUser: unknown) => void;
+  flushAsync: () => Promise<void>;
 }
 declare function createResolver<TSlices extends Record<string, SliceDefinition>>(slices: TSlices): Resolver<TSlices>;
-
+//#endregion
+//#region src/scope.d.ts
 type Scope = Record<string, unknown> | null;
 interface ScopeChainEntry {
-    name: string;
-    scope: (ctx: never) => Scope;
+  name: string;
+  scope: (ctx: never) => Scope;
 }
 /**
  * Shallow merge two scope objects. Patch wins on conflict.
@@ -171,27 +183,30 @@ declare function mergeScope(base: Scope, patch: Scope): Scope;
  */
 declare function cascadeScope(chain: ScopeChainEntry[], ctx: never): Scope;
 interface RequireScopeOk {
-    ok: true;
+  ok: true;
 }
 interface RequireScopeFail {
-    ok: false;
-    missing: string[];
+  ok: false;
+  missing: string[];
 }
 type RequireScopeResult = RequireScopeOk | RequireScopeFail;
 /**
  * Verify all required keys are present (and not undefined) in scope.
  */
 declare function checkRequireScope(scope: Scope, required: string[]): RequireScopeResult;
-
+//#endregion
+//#region src/permissions.d.ts
 declare function createPendingPermissions(): PermissionMap;
 declare function createErrorPermissions(error: unknown): PermissionMap;
 interface ReadyPermissionsConfig {
-    can: (action: string, resource: string, record?: unknown) => boolean;
-    reason?: (action: string, resource: string, record?: unknown) => string | undefined;
+  can: (action: string, resource: string, record?: unknown) => boolean;
+  reason?: (action: string, resource: string, record?: unknown) => string | undefined;
 }
 declare function createReadyPermissions(config: ReadyPermissionsConfig): PermissionMap;
-
+//#endregion
+//#region src/index.d.ts
 declare const PACKAGE_NAME: "@burojs/context";
 declare const PACKAGE_VERSION: "0.0.0";
-
+//#endregion
 export { type AsyncSliceConfig, type AsyncSliceDefinition, type Atom, type AuthInvalidationEvent, type DagNode, type FromAuthSliceConfig, type FromAuthSliceDefinition, PACKAGE_NAME, PACKAGE_VERSION, type PermissionMap, type PermissionStatus, type PickerPersistMode, type PickerSliceConfig, type PickerSliceDefinition, type ReadyPermissionsConfig, type RequireScopeFail, type RequireScopeOk, type RequireScopeResult, type Resolver, type Scope, type ScopeChainEntry, type SliceBuilder, type SliceDefinition, type SliceKind, type StaticSliceConfig, type StaticSliceDefinition, type Store, type TrackedReadResult, cascadeScope, checkRequireScope, createAtom, createErrorPermissions, createPendingPermissions, createReadyPermissions, createResolver, createStore, defineAsyncSlice, defineContextSlices, defineFromAuthSlice, definePickerSlice, defineStaticSlice, mergeScope, topoSort, trackReads };
+//# sourceMappingURL=index.d.ts.map