state-management-utilities
Version:
State management utilities
143 lines (142 loc) • 4.86 kB
JavaScript
/* istanbul ignore file */
import { TaskManagerCore } from "task-manager-core";
import { center } from "./center";
import { StateManager } from "./state-manager";
export class TaskManager extends TaskManagerCore {
_initializeManager({ name, initialValue, configs, }) {
const uid = `${this._uid}/${name}`;
return new StateManager(initialValue, {
uid,
...configs,
});
}
_uid = `TM-#${counter++}`;
state;
error;
isProcessing;
_requestDetails_;
get uid() {
return this._uid;
}
get requestDetails() {
return {
value: this._requestDetails_.value,
};
}
_setRequestDetails(updater) {
this._requestDetails_.set(updater);
}
constructor({ uid, stateConfig, errorConfig, isProcessingConfig, requestParamsConfig, ...configs }) {
const defaultEventHandlers = {
...configs.defaultEventHandlers,
onCache: async (props, instance) => {
this.state.value = props.cache?.data ?? null;
if (center.isHydration)
return;
configs.defaultEventHandlers?.onCache?.(props, instance);
},
onRequest: async (props, instance) => {
this.isProcessing.value = true;
if (center.isHydration)
return;
configs.defaultEventHandlers?.onRequest?.(props, instance);
},
onSuccess: async (props, instance) => {
this.state.value = props.data ?? null;
if (center.isHydration)
return;
configs.defaultEventHandlers?.onSuccess?.(props, instance);
},
onError: async (props, instance) => {
this.error.value = props.error;
if (center.isHydration)
return;
configs.defaultEventHandlers?.onError?.(props, instance);
},
onFinally: async (props, instance) => {
this.isProcessing.value = false;
if (center.isHydration)
return;
configs.defaultEventHandlers?.onFinally?.(props, instance);
},
};
const newConfigs = {
...configs,
defaultEventHandlers,
};
super(newConfigs);
if (uid)
this._uid = uid;
this.state = this._initializeManager({
name: "state",
initialValue: stateConfig?.initialValue ?? null,
configs: stateConfig ?? {},
});
this.error = this._initializeManager({
name: "error",
initialValue: errorConfig?.initialValue ?? null,
configs: errorConfig ?? {},
});
this.isProcessing = this._initializeManager({
name: "is-processing",
initialValue: isProcessingConfig?.initialValue ?? false,
configs: isProcessingConfig ?? {},
});
this._requestDetails_ = this._initializeManager({
name: "request-details",
initialValue: requestParamsConfig?.initialValue ?? this._defaultRequestDetails,
configs: requestParamsConfig ?? {},
});
center._registerCacheRef({ uid: this.uid, ref: this });
}
reset() {
this.state.reset();
this.error.reset();
this.isProcessing.reset();
this._requestDetails_.reset();
this._retriedOnError = 0;
return this;
}
_isPrevented({ hash, config, }) {
return center.isHydration ? false : super._isPrevented({ hash, config });
}
async hydrate(...parameters) {
const result = await this._requestCore({
parameters,
config: { isInvalidate: true },
});
const { hash, createdAt, updatedAt, data, error, isError } = result;
const cacheRef = this.uid;
const UIDs = {
state: this.state.uid,
error: this.error.uid,
details: this._requestDetails_.uid,
};
const details = {
updatedAt,
createdAt,
isFailed: Boolean(isError),
isSucceed: !isError,
parameters,
};
return {
update: (record) => {
if (data !== undefined)
record[UIDs.state] = {
value: data,
hash,
cacheRef,
};
if (error !== undefined)
record[UIDs.error] = {
value: error,
};
record[UIDs.details] = {
value: details,
};
},
value: result,
};
}
}
let counter = 0;