111 lines
3.6 KiB
TypeScript
111 lines
3.6 KiB
TypeScript
import * as plugins from './smartstate.plugins.js';
|
|
import { StatePart } from './smartstate.classes.statepart.js';
|
|
|
|
export type TInitMode = 'soft' | 'mandatory' | 'force' | 'persistent';
|
|
|
|
/**
|
|
* Smartstate takes care of providing state
|
|
*/
|
|
export class Smartstate<StatePartNameType extends string> {
|
|
public statePartMap: { [key in StatePartNameType]?: StatePart<StatePartNameType, any> } = {};
|
|
|
|
private pendingStatePartCreation: Map<string, Promise<StatePart<StatePartNameType, any>>> = new Map();
|
|
|
|
constructor() {}
|
|
|
|
/**
|
|
* Allows getting and initializing a new statepart
|
|
* initMode === 'soft' (default) - returns existing statepart if exists, creates new if not
|
|
* initMode === 'mandatory' - requires statepart to not exist, fails if it does
|
|
* initMode === 'force' - always creates new statepart, overwriting any existing
|
|
* initMode === 'persistent' - like 'soft' but with webstore persistence
|
|
* @param statePartNameArg
|
|
* @param initialArg
|
|
* @param initMode
|
|
*/
|
|
public async getStatePart<PayloadType>(
|
|
statePartNameArg: StatePartNameType,
|
|
initialArg?: PayloadType,
|
|
initMode: TInitMode = 'soft'
|
|
): Promise<StatePart<StatePartNameType, PayloadType>> {
|
|
// Return pending creation if one exists to prevent duplicate state parts
|
|
const pending = this.pendingStatePartCreation.get(statePartNameArg);
|
|
if (pending) {
|
|
return pending as Promise<StatePart<StatePartNameType, PayloadType>>;
|
|
}
|
|
|
|
const existingStatePart = this.statePartMap[statePartNameArg];
|
|
|
|
if (existingStatePart) {
|
|
switch (initMode) {
|
|
case 'mandatory':
|
|
throw new Error(
|
|
`State part '${statePartNameArg}' already exists, but initMode is 'mandatory'`
|
|
);
|
|
case 'force':
|
|
// Force mode: create new state part
|
|
break; // Fall through to creation
|
|
case 'soft':
|
|
case 'persistent':
|
|
default:
|
|
// Return existing state part
|
|
return existingStatePart as StatePart<StatePartNameType, PayloadType>;
|
|
}
|
|
} else {
|
|
// State part doesn't exist
|
|
if (!initialArg) {
|
|
throw new Error(
|
|
`State part '${statePartNameArg}' does not exist and no initial state provided`
|
|
);
|
|
}
|
|
}
|
|
|
|
const creationPromise = this.createStatePart<PayloadType>(statePartNameArg, initialArg, initMode);
|
|
this.pendingStatePartCreation.set(statePartNameArg, creationPromise);
|
|
|
|
try {
|
|
const result = await creationPromise;
|
|
return result;
|
|
} finally {
|
|
this.pendingStatePartCreation.delete(statePartNameArg);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a statepart
|
|
* @param statePartName
|
|
* @param initialPayloadArg
|
|
* @param initMode
|
|
*/
|
|
private async createStatePart<PayloadType>(
|
|
statePartName: StatePartNameType,
|
|
initialPayloadArg: PayloadType,
|
|
initMode: TInitMode = 'soft'
|
|
): Promise<StatePart<StatePartNameType, PayloadType>> {
|
|
const newState = new StatePart<StatePartNameType, PayloadType>(
|
|
statePartName,
|
|
initMode === 'persistent'
|
|
? {
|
|
dbName: 'smartstate',
|
|
storeName: statePartName,
|
|
}
|
|
: null
|
|
);
|
|
await newState.init();
|
|
const currentState = newState.getState();
|
|
|
|
if (initMode === 'persistent' && currentState !== undefined) {
|
|
// Persisted state exists - merge with defaults, persisted values take precedence
|
|
await newState.setState({
|
|
...initialPayloadArg,
|
|
...currentState,
|
|
});
|
|
} else {
|
|
// No persisted state or non-persistent mode
|
|
await newState.setState(initialPayloadArg);
|
|
}
|
|
|
|
this.statePartMap[statePartName] = newState;
|
|
return newState;
|
|
}
|
|
} |