@civet/core 1.4.3 → 2.0.0

package/dist/AbortSignal.d.ts

@@ -0,0 +1,16 @@
+import { default as Notifier } from './Notifier';
+export type AbortSignalProxy = {
+    listen: AbortSignal['listen'];
+    locked: AbortSignal['locked'];
+    aborted: AbortSignal['aborted'];
+};
+export default class AbortSignal {
+    notifier: Notifier<never[]>;
+    readonly locked: boolean;
+    readonly aborted: boolean;
+    constructor();
+    listen: (cb: () => void) => (() => void);
+    abort: () => void;
+    lock: () => void;
+    proxy: () => AbortSignalProxy;
+}

package/dist/ChannelNotifier.d.ts

@@ -0,0 +1,6 @@
+export default class ChannelNotifier<TriggerArgs extends unknown[] = never[]> {
+    private channels;
+    subscribe: (channel: string, callback: (...args: TriggerArgs) => void) => (() => void);
+    isSubscribed: (channel: string, callback: (...args: TriggerArgs) => void) => boolean;
+    trigger: (channel: string, ...args: TriggerArgs) => void;
+}

package/dist/ConfigProvider.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren, ReactNode } from 'react';
+import { GenericDataProvider } from './DataProvider';
+/**
+ * Provides general configuration to its descendants using React's context API.
+ */
+export default function ConfigProvider<DataProviderI extends GenericDataProvider>({ dataProvider, children, }: PropsWithChildren<{
+    dataProvider: DataProviderI;
+}>): ReactNode;

package/dist/DataProvider.d.ts

@@ -0,0 +1,110 @@
+import { ReactNode } from 'react';
+import { default as AbortSignal, AbortSignalProxy } from './AbortSignal';
+import { default as ChannelNotifier } from './ChannelNotifier';
+import { default as Meta, MetaLike, RawMeta } from './Meta';
+export type RequestDetails<Query, Options> = {
+    name: string;
+    query: Query;
+    empty: boolean;
+    options: Options | undefined;
+};
+export type ResourceBaseContext<Item, Query, Options> = {
+    name: string;
+    query: Query;
+    options: Options | undefined;
+    request: string;
+    revision: string;
+    data: Item[];
+    meta: RawMeta;
+    error: Error | undefined;
+    isEmpty: boolean;
+    isIncomplete: boolean;
+    isInitial: boolean;
+};
+export type ResourceContextValue<DataProviderI extends GenericDataProvider, ItemI extends InferItem<DataProviderI> = InferItem<DataProviderI>, QueryI extends InferQuery<DataProviderI> = InferQuery<DataProviderI>, OptionsI extends InferOptions<DataProviderI> = InferOptions<DataProviderI>> = ResourceBaseContext<ItemI, QueryI, OptionsI> & {
+    dataProvider: DataProviderI;
+    isLoading: boolean;
+    isStale: boolean;
+    next: {
+        request: string;
+        revision: string;
+    };
+    notify: () => Promise<{
+        request: string;
+        revision: string;
+    }>;
+};
+export type ContextPlugin<PluginProps = unknown, PluginTypes = unknown> = (context: ResourceContextValue<GenericDataProvider>, props: PluginProps) => ResourceContextValue<GenericDataProvider> & PluginTypes;
+export type UIPlugin<PluginProps = unknown, PluginTypes = unknown> = React.ComponentType<PluginProps & {
+    context: ResourceContextValue<GenericDataProvider>;
+    children: (context: ResourceContextValue<GenericDataProvider> & PluginTypes) => ReactNode | undefined;
+}>;
+export type Persistence = boolean | 'very';
+export type GetCallback<Item> = (error: Error | undefined, done: boolean, result: Item[]) => void;
+export type ContinuousGet<Item> = (callback: GetCallback<Item>, 
+/** @deprecated Use the `abortSignal` that is provided by `handleGet` instead. */
+abortSignal: AbortSignalProxy) => void;
+export default abstract class DataProvider<Item, Query, Options, Instance = unknown, CreateData = Item, CreateResult = void, UpdateData = Item, UpdateResult = void, PatchData = Partial<Item>, PatchResult = void, RemoveResult = void> {
+    readonly _inferItem: Item;
+    readonly _inferQuery: Query;
+    readonly _inferOptions: Options;
+    readonly _inferInstance: Instance;
+    readonly _inferCreateData: CreateData;
+    readonly _inferCreateResult: CreateResult;
+    readonly _inferUpdateData: UpdateData;
+    readonly _inferUpdateResult: UpdateResult;
+    readonly _inferPatchData: PatchData;
+    readonly _inferPatchResult: PatchResult;
+    readonly _inferRemoveResult: RemoveResult;
+    notifier: ChannelNotifier<never[]>;
+    readonly contextPlugins: ContextPlugin<unknown, unknown>[];
+    readonly uiPlugins: UIPlugin<unknown, unknown>[];
+    constructor();
+    extend(_extend: {
+        context: (plugin: ContextPlugin<unknown, unknown>) => void;
+        ui: (plugin: UIPlugin<unknown, unknown>) => void;
+    }): void;
+    createInstance(): Instance | undefined;
+    releaseInstance(_: Instance): void;
+    subscribe(resource: string, callback: () => void): () => void;
+    notify(resource: string): void;
+    get<ItemI extends Item = Item, QueryI extends Query = Query, OptionsI extends Options = Options>(resource: string, query: QueryI, options?: OptionsI, meta?: MetaLike<Instance>, abortSignal?: AbortSignal): Promise<ItemI[]>;
+    continuousGet<ItemI extends Item = Item, QueryI extends Query = Query, OptionsI extends Options = Options>(resource: string, query: QueryI, options: OptionsI | undefined, meta: MetaLike<Instance> | undefined, callback: GetCallback<ItemI>, abortSignal?: AbortSignal): void;
+    abstract handleGet(resource: string, query: Query, options: Options | undefined, meta: Meta<Instance>, abortSignal: AbortSignalProxy): Promise<Item[]> | Item[] | ContinuousGet<Item>;
+    create<CreateDataI extends CreateData = CreateData, CreateResultI extends CreateResult = CreateResult, OptionsI extends Options = Options>(resource: string, data: CreateDataI, options?: OptionsI, meta?: MetaLike<Instance>): Promise<CreateResultI>;
+    abstract handleCreate(resource: string, data: CreateData, options: Options | undefined, meta: Meta<Instance>): Promise<CreateResult> | CreateResult;
+    update<UpdateDataI extends UpdateData = UpdateData, UpdateResultI extends UpdateResult = UpdateResult, QueryI extends Query = Query, OptionsI extends Options = Options>(resource: string, query: QueryI, data: UpdateDataI, options?: OptionsI, meta?: MetaLike<Instance>): Promise<UpdateResultI>;
+    abstract handleUpdate(resource: string, query: Query, data: UpdateData, options: Options | undefined, meta: Meta<Instance>): Promise<UpdateResult> | UpdateResult;
+    patch<PatchDataI extends PatchData = PatchData, PatchResultI extends PatchResult = PatchResult, QueryI extends Query = Query, OptionsI extends Options = Options>(resource: string, query: QueryI, data: PatchDataI, options?: OptionsI, meta?: MetaLike<Instance>): Promise<PatchResultI>;
+    abstract handlePatch(resource: string, query: Query, data: PatchData, options: Options | undefined, meta: Meta<Instance>): Promise<PatchResult> | PatchResult;
+    remove<RemoveResultI extends RemoveResult = RemoveResult, QueryI extends Query = Query, OptionsI extends Options = Options>(resource: string, query: QueryI, options?: OptionsI, meta?: MetaLike<Instance>): Promise<RemoveResultI>;
+    abstract handleRemove(resource: string, query: Query, options: Options | undefined, meta: Meta<Instance>): Promise<RemoveResult> | RemoveResult;
+    compareRequests(nextRequestDetails: RequestDetails<Query, Options>, prevRequestDetails: RequestDetails<Query, Options>): boolean;
+    shouldPersist(nextRequestDetails: RequestDetails<Query, Options>, prevRequestDetails: RequestDetails<Query, Options>, persistent: Persistence, _context: ResourceBaseContext<Item, Query, Options>): boolean;
+    compareItemVersions(_item1: Item, _item2: Item): boolean;
+    getItemIdentifier(item: Item): string;
+    transition(nextContext: ResourceBaseContext<Item, Query, Options>, _prevContext: ResourceBaseContext<Item, Query, Options>): Item[];
+    recycleItems(nextContext: ResourceBaseContext<Item, Query, Options>, prevContext: ResourceBaseContext<Item, Query, Options>): Item[];
+}
+export declare const isDataProvider: (dataProvider: unknown) => boolean;
+export type Constructor<Args extends any[], T> = new (...args: Args) => T;
+export type DataProviderImplementation<DataProviderI extends GenericDataProvider, ConstructorArgs extends any[]> = Constructor<ConstructorArgs, DataProviderI & {
+    handleGet(resource: string, query: InferQuery<DataProviderI>, options: InferOptions<DataProviderI> | undefined, meta: Meta<InferInstance<DataProviderI>>, abortSignal: AbortSignalProxy): Promise<InferItem<DataProviderI>[]> | InferItem<DataProviderI>[] | ContinuousGet<InferItem<DataProviderI>>;
+    handleCreate(resource: string, data: InferCreateData<DataProviderI>, options: InferOptions<DataProviderI> | undefined, meta: Meta<InferInstance<DataProviderI>>): Promise<InferCreateResult<DataProviderI>> | InferCreateResult<DataProviderI>;
+    handleUpdate(resource: string, query: InferQuery<DataProviderI>, data: InferUpdateData<DataProviderI>, options: InferOptions<DataProviderI> | undefined, meta: Meta<InferInstance<DataProviderI>>): Promise<InferUpdateResult<DataProviderI>> | InferUpdateResult<DataProviderI>;
+    handlePatch(resource: string, query: InferQuery<DataProviderI>, data: InferPatchData<DataProviderI>, options: InferOptions<DataProviderI> | undefined, meta: Meta<InferInstance<DataProviderI>>): Promise<InferPatchResult<DataProviderI>> | InferPatchResult<DataProviderI>;
+    handleRemove(resource: string, query: InferQuery<DataProviderI>, options: InferOptions<DataProviderI> | undefined, meta: Meta<InferInstance<DataProviderI>>): Promise<InferRemoveResult<DataProviderI>> | InferRemoveResult<DataProviderI>;
+}>;
+export type GenericDataProvider = DataProvider<unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown, unknown>;
+export type GenericDataProviderImplementation = DataProviderImplementation<GenericDataProvider, any[]>;
+export type InferItem<DataProviderI extends GenericDataProvider> = DataProviderI['_inferItem'];
+export type InferQuery<DataProviderI extends GenericDataProvider> = DataProviderI['_inferQuery'];
+export type InferOptions<DataProviderI extends GenericDataProvider> = DataProviderI['_inferOptions'];
+export type InferInstance<DataProviderI extends GenericDataProvider> = DataProviderI['_inferInstance'];
+export type InferCreateData<DataProviderI extends GenericDataProvider> = DataProviderI['_inferCreateData'];
+export type InferCreateResult<DataProviderI extends GenericDataProvider> = DataProviderI['_inferCreateResult'];
+export type InferUpdateData<DataProviderI extends GenericDataProvider> = DataProviderI['_inferUpdateData'];
+export type InferUpdateResult<DataProviderI extends GenericDataProvider> = DataProviderI['_inferUpdateResult'];
+export type InferPatchData<DataProviderI extends GenericDataProvider> = DataProviderI['_inferPatchData'];
+export type InferPatchResult<DataProviderI extends GenericDataProvider> = DataProviderI['_inferPatchResult'];
+export type InferRemoveResult<DataProviderI extends GenericDataProvider> = DataProviderI['_inferRemoveResult'];

package/dist/Meta.d.ts

@@ -0,0 +1,18 @@
+export type RawMeta = {
+    [key: string]: unknown;
+};
+export type MetaLike<Instance = unknown> = Meta<Instance> | RawMeta;
+export default class Meta<Instance = unknown> {
+    data: RawMeta;
+    instance?: Instance;
+    constructor(base?: RawMeta, instance?: Instance);
+    clear: () => void;
+    delete: (key: string) => unknown;
+    entries: () => [string, unknown][];
+    get: (key: string) => unknown;
+    has: (key: string) => boolean;
+    keys: () => string[];
+    set: (key: string, value: unknown) => void;
+    values: () => unknown[];
+    commit: (prev: RawMeta, ignore?: string[]) => RawMeta;
+}

package/dist/Notifier.d.ts

@@ -0,0 +1,6 @@
+export default class Notifier<TriggerArgs extends unknown[] = never[]> {
+    listeners: Set<(...args: TriggerArgs) => void>;
+    subscribe: (callback: (...args: TriggerArgs) => void) => (() => void);
+    isSubscribed: (callback: (...args: TriggerArgs) => void) => boolean;
+    trigger: (...args: TriggerArgs) => void;
+}

package/dist/Resource.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+import { GenericDataProvider, InferItem, InferOptions, InferQuery, Persistence } from './DataProvider';
+/**
+ * Provides data based on the given request details and DataProvider.
+ * Context provider for the ResourceContext.
+ *
+ * Necessary configuration that is not directly specified is taken from the ConfigContext.
+ *
+ * The provided DataProvider must not be changed.
+ */
+export default function Resource<DataProviderI extends GenericDataProvider, ItemI extends InferItem<DataProviderI> = InferItem<DataProviderI>, QueryI extends InferQuery<DataProviderI> = InferQuery<DataProviderI>, OptionsI extends InferOptions<DataProviderI> = InferOptions<DataProviderI>>({ dataProvider, name, query, empty, options, persistent, children, ...rest }: {
+    dataProvider?: DataProviderI;
+    name: string;
+    query: QueryI;
+    empty?: boolean;
+    options?: OptionsI;
+    persistent?: Persistence;
+    children?: ReactNode;
+    [rest: string]: unknown;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/ResourceProvider.d.ts

@@ -0,0 +1,5 @@
+import { PropsWithChildren, ReactNode } from 'react';
+import { GenericDataProvider, InferItem, InferOptions, InferQuery, ResourceContextValue } from './DataProvider';
+export default function ResourceProvider<DataProviderI extends GenericDataProvider, ItemI extends InferItem<DataProviderI> = InferItem<DataProviderI>, QueryI extends InferQuery<DataProviderI> = InferQuery<DataProviderI>, OptionsI extends InferOptions<DataProviderI> = InferOptions<DataProviderI>>({ resource, children, }: PropsWithChildren<{
+    resource: ResourceContextValue<DataProviderI, ItemI, QueryI, OptionsI>;
+}>): ReactNode;

package/dist/compose.d.ts

@@ -0,0 +1 @@
+export default function compose<Arg>(...fn: ((arg: Arg) => Arg)[]): (arg: Arg) => Arg;

package/dist/context.d.ts

@@ -0,0 +1,15 @@
+import { ConsumerProps, ExoticComponent, ReactNode } from 'react';
+import { GenericDataProvider, InferItem, InferOptions, InferQuery, ResourceContextValue } from './DataProvider';
+export type ConfigContextValue<DataProviderI extends GenericDataProvider> = {
+    dataProvider?: DataProviderI;
+};
+export declare const ConfigContext: import('react').Context<ConfigContextValue<GenericDataProvider>>;
+export declare const ConfigConsumer: ExoticComponent<GenericDataProvider> & {
+    <DataProviderI extends GenericDataProvider>(props: ConsumerProps<ConfigContextValue<DataProviderI>>): ReactNode;
+};
+export declare const useConfigContext: <DataProviderI extends GenericDataProvider>() => ConfigContextValue<DataProviderI>;
+export declare const ResourceContext: import('react').Context<ResourceContextValue<GenericDataProvider>>;
+export declare const ResourceConsumer: ExoticComponent<GenericDataProvider> & {
+    <DataProviderI extends GenericDataProvider, ItemI extends InferItem<DataProviderI> = InferItem<DataProviderI>, QueryI extends InferQuery<DataProviderI> = InferQuery<DataProviderI>, OptionsI extends InferOptions<DataProviderI> = InferOptions<DataProviderI>>(props: ConsumerProps<ResourceContextValue<DataProviderI, ItemI, QueryI, OptionsI>>): ReactNode;
+};
+export declare const useResourceContext: <DataProviderI extends GenericDataProvider, ItemI extends InferItem<DataProviderI> = InferItem<DataProviderI>, QueryI extends InferQuery<DataProviderI> = InferQuery<DataProviderI>, OptionsI extends InferOptions<DataProviderI> = InferOptions<DataProviderI>>() => ResourceContextValue<DataProviderI, ItemI, QueryI, OptionsI>;

package/dist/createPlugin.d.ts

@@ -0,0 +1,4 @@
+import { Constructor, GenericDataProviderImplementation } from './DataProvider';
+export type DataProviderImplementationWithPlugin<BaseDataProvider extends GenericDataProviderImplementation, PluginTypes> = Pick<BaseDataProvider, keyof BaseDataProvider> & Constructor<ConstructorParameters<BaseDataProvider>, InstanceType<BaseDataProvider> & PluginTypes>;
+export type DataProviderPlugin<BaseDataProvider extends GenericDataProviderImplementation, PluginTypes> = <BaseDataProviderT extends BaseDataProvider>(baseDataProviderClass: BaseDataProviderT) => DataProviderImplementationWithPlugin<BaseDataProviderT, PluginTypes>;
+export default function createPlugin<BaseDataProvider extends GenericDataProviderImplementation, PluginTypes>(plugin: (baseDataProviderClass: Pick<BaseDataProvider, keyof BaseDataProvider> & Constructor<any[], InstanceType<BaseDataProvider>>) => DataProviderImplementationWithPlugin<Pick<BaseDataProvider, keyof BaseDataProvider> & Constructor<any[], InstanceType<BaseDataProvider>>, PluginTypes>): DataProviderPlugin<BaseDataProvider, PluginTypes>;

package/dist/main.d.ts

@@ -0,0 +1,18 @@
+import { ConfigConsumer, ResourceConsumer, useConfigContext, useResourceContext } from './context';
+export { default as AbortSignal } from './AbortSignal';
+export type { AbortSignalProxy } from './AbortSignal';
+export { default as ChannelNotifier } from './ChannelNotifier';
+export { default as compose } from './compose';
+export { default as ConfigProvider } from './ConfigProvider';
+export type { ConfigContextValue } from './context';
+export { default as createPlugin } from './createPlugin';
+export type { DataProviderImplementationWithPlugin, DataProviderPlugin, } from './createPlugin';
+export { default as DataProvider, isDataProvider } from './DataProvider';
+export type { Constructor, ContextPlugin, ContinuousGet, DataProviderImplementation, GenericDataProvider, GenericDataProviderImplementation, GetCallback, InferCreateData, InferCreateResult, InferInstance, InferItem, InferOptions, InferPatchData, InferPatchResult, InferQuery, InferRemoveResult, InferUpdateData, InferUpdateResult, Persistence, RequestDetails, ResourceBaseContext, ResourceContextValue, UIPlugin, } from './DataProvider';
+export { default as Meta } from './Meta';
+export type { MetaLike, RawMeta } from './Meta';
+export { default as Notifier } from './Notifier';
+export { default as Resource } from './Resource';
+export { default as ResourceProvider } from './ResourceProvider';
+export { default as useResource } from './useResource';
+export { ConfigConsumer, ResourceConsumer, useConfigContext, useResourceContext, };