@qpqjs/core 0.3.0 → 0.5.0

package/lib/esm/stories/system/askOverrideActions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"askOverrideActions.js","sourceRoot":"","sources":["../../../../src/stories/system/askOverrideActions.ts"],"names":[],"mappings":"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","sourcesContent":["import { askBatch, askThrowError, SystemActionType, SystemBatchActionPayload } from '../../actions';\nimport { getSuccessfulEitherActionResult } from '../../logic/actionLogic';\nimport { Action, AskResponse, AskResponseReturnType, EitherActionResult } from '../../types';\nimport { askMapParallel } from '../array/askMapParallel';\nimport { askCatch } from './askCatch';\n\n// A function that takes an action and returns a story (generator) that produces the override result.\n// This is what the user provides for each action type they want to intercept.\nexport type ActionOverrideHandler<TAction extends Action<any> = Action<any>, TResult = any> = (action: TAction) => AskResponse<TResult>;\n\n// A map of action type strings to their override handlers.\n// The key is the action type (e.g. \"MathActionType.RandomNumber\") or \"*\" for a wildcard catch-all.\n// The value is the handler function that will run instead of the normal action processor.\nexport type ActionOverrideMap = {\n  [actionType: string]: ActionOverrideHandler<any, any>;\n};\n\n// Looks up a handler as an OWN property of the override map. A plain-object map inherits from\n// Object.prototype, so an action type like \"toString\" or \"constructor\" would otherwise resolve\n// to an inherited function and get invoked as a handler.\nfunction getOwnOverrideHandler(overrides: ActionOverrideMap, actionType: string): ActionOverrideHandler | undefined {\n  return Object.prototype.hasOwnProperty.call(overrides, actionType) ? overrides[actionType] : undefined;\n}\n\n// A tiny helper story that just yields a single action and returns whatever the processor gives back.\n// We use this to wrap individual actions so we can pass them into askOverrideActions recursively.\n// For example, when we pull an action out of a batch, we wrap it in this so askOverrideActions\n// can intercept it as if it were a normal top-level action being yielded by a story.\nfunction* askProcessAction<R>(action: Action<any>): AskResponse<R> {\n  return (yield action) as R;\n}\n\n// Shapes a handler's OWN computed value into what the story expects.\n//\n// When an action has returnErrors set to true (because askCatch wrapped it), the story expects the\n// result wrapped in { success: true, result: value }. The runtime normally does this, but an override\n// bypasses the runtime — so a handler that returns a value it computed itself must shape it with this\n// helper (passing the action's returnErrors). If returnErrors is false/undefined it returns the value\n// unchanged.\n//\n// Handlers that simply RELAY the action with `return yield action` must NOT call this: the value they\n// get back from the parent is already in the right shape (raw, or an EitherActionResult when the\n// action carried returnErrors), and the engine forwards a handler's return value verbatim.\nexport function getSuccessfulEitherActionResultIfRequired<T, ReturnErrors extends boolean>(\n  value: T,\n  returnErrors?: ReturnErrors,\n): ReturnErrors extends true ? EitherActionResult<T> : T {\n  if (returnErrors) {\n    return getSuccessfulEitherActionResult(value) as ReturnErrors extends true ? EitherActionResult<T> : T;\n  } else {\n    // returnErrors is false, so just pass the raw value through unchanged\n    return value as ReturnErrors extends true ? EitherActionResult<T> : T;\n  }\n}\n\n// This is the main function. It sits between a story and the runtime, intercepting actions\n// as the story yields them. If an action matches one of the overrides (by type or wildcard \"*\"),\n// we run the override handler instead of letting the runtime process it. If the action doesn't\n// match any override, we yield it up to the parent (the runtime) and let it handle things normally.\n//\n// The tricky part is batches. When stories run things in parallel (askRunParallel), the actions\n// get bundled into a single batch action. We need to crack open the batch, check each action\n// inside for overrides, handle those ourselves, and then send the remaining non-overridden\n// actions back out as a smaller batch for the runtime to process. We also need to handle\n// batches-inside-batches by recursing, so overrides work no matter how deeply nested things are.\nexport function* askOverrideActions<T extends AskResponse<any>>(\n  storyIterator: T,\n  overrides: ActionOverrideMap,\n): AskResponse<AskResponseReturnType<T>> {\n  // Kick off the story by calling .next() to get the first yielded action\n  let nextResult = storyIterator.next();\n\n  // Keep looping as long as the story has more actions to yield.\n  // When the story is done (returns a value instead of yielding), nextResult.done will be true.\n  while (!nextResult.done) {\n    // This is the action the story just yielded - it wants someone to process it\n    const action = nextResult.value;\n\n    // Check if we have an override for this specific action type, or a \"*\" wildcard catch-all.\n    // The specific type takes priority over the wildcard because we check it first.\n    const handler =\n      getOwnOverrideHandler(overrides, action.type) || (action.type !== SystemActionType.Batch ? getOwnOverrideHandler(overrides, '*') : undefined);\n    if (handler) {\n      // We have an override! Run the user's handler instead of letting the runtime process it.\n      // The handler is itself a story (generator), so we yield* into it to run it.\n      //\n      // We feed the handler's return value to the story VERBATIM — we never reshape it. That is what\n      // lets a handler relay an action with a bare `return yield action`: the value it gets back from\n      // the parent (raw, or an EitherActionResult when the action carries returnErrors, e.g. under\n      // askCatch) is already exactly what the story expects. A handler that instead returns its OWN\n      // computed value is responsible for shaping it (see getSuccessfulEitherActionResultIfRequired).\n      nextResult = storyIterator.next(yield* handler(action));\n\n      // Skip to the next iteration of the while loop to process the next yielded action\n      continue;\n    }\n\n    // If we get here, the action wasn't directly overridden.\n    // But it might be a batch action (from askRunParallel / askBatch) that contains\n    // overridden actions inside it. We need to crack it open and check each one.\n    if (action.type === SystemActionType.Batch) {\n      // Pull out the list of individual actions that are bundled inside this batch\n      const batchActionPayload: SystemBatchActionPayload = action.payload;\n\n      // Go through every action in the batch one by one using askMap.\n      // For each action, we figure out if we need to handle it ourselves (override or nested batch)\n      // or if we can leave it for the runtime to process in the remaining batch.\n      const batchActionsToRun = yield* askMapParallel(batchActionPayload.actions, function* (batchAction) {\n        // Does this individual action have an override handler (specific type or wildcard)?\n        const isOverridden = !!(getOwnOverrideHandler(overrides, batchAction.type) || getOwnOverrideHandler(overrides, '*'));\n\n        // Is this individual action itself another batch? If so, it could contain overridden\n        // actions deeper inside, so we need to recurse into it even though we don't override\n        // the batch action itself.\n        const isBatch = batchAction.type === SystemActionType.Batch;\n\n        // We need to recursively process this action if it's either:\n        // 1. Directly overridden (we have a handler for it)\n        // 2. A nested batch (it might contain overridden actions inside)\n        const needsRecursion = isOverridden || isBatch;\n\n        return {\n          action: batchAction,\n          // Track whether we already processed this action ourselves, so we know not to\n          // send it to the runtime again later\n          alreadyProcessed: needsRecursion,\n          // If we need to process it, wrap the action in askProcessAction (which makes it look\n          // like a story that yields one action) and run it through askOverrideActions recursively.\n          // This handles both direct overrides and nested batches-within-batches.\n          //\n          // The recursion is wrapped in askCatch so a failing sub-action becomes a captured\n          // failure for THIS slot instead of escaping bare and bypassing the enclosing batch's\n          // returnErrors protection. All slot results are held as EitherActionResults; the\n          // successful ones are unwrapped when the batch is reassembled below.\n          //\n          // If we don't need to process it, leave the result undefined for now - the runtime\n          // will fill it in when we send the remaining batch.\n          result: needsRecursion ? yield* askCatch(askOverrideActions(askProcessAction(batchAction), overrides)) : undefined,\n        };\n      });\n\n      // Now split the batch actions into two groups:\n      // - alreadyProcessed: we handled these above (overridden or nested batches) and have results\n      // - remaining: these are normal actions we need to send to the runtime to process\n      const remainingBatchActionsToRun = batchActionsToRun.filter((ba) => !ba.alreadyProcessed);\n\n      // Send the remaining non-overridden actions to the runtime as a batch.\n      // We wrap this in askCatch so that if any action in the batch fails, we get the error\n      // back as a value instead of it throwing and killing everything.\n      const results = yield* askCatch(askBatch(remainingBatchActionsToRun.map((ba) => ba.action)));\n\n      // If the batch succeeded, take each result from the runtime and attach it to the\n      // corresponding action object (wrapped so every slot holds an EitherActionResult),\n      // so we can reassemble the full results array later.\n      if (results.success) {\n        remainingBatchActionsToRun.forEach((ba, index) => {\n          ba.result = getSuccessfulEitherActionResult(results.result[index]);\n        });\n      }\n\n      // One failure fails the whole batch, matching the runtime's batch semantics: a runtime\n      // batch failure wins, otherwise the first captured failure from an overridden slot.\n      const isFailedSlotResult = (slotResult: EitherActionResult<any> | undefined): slotResult is EitherActionResult<any> & { success: false } =>\n        slotResult !== undefined && !slotResult.success;\n      const failedResult = !results.success ? results : batchActionsToRun.map((ba) => ba.result).find(isFailedSlotResult);\n\n      // If any sub-action failed (in the runtime batch or in an overridden slot)\n      if (failedResult) {\n        // Check if the caller wants errors returned as values (askCatch set returnErrors: true)\n        if (!action.returnErrors) {\n          // No askCatch protecting this, so throw the error up to crash the story\n          return yield* askThrowError(failedResult.error.errorType, failedResult.error.errorText, failedResult.error.errorStack);\n        } else {\n          // askCatch is protecting this, so pass the error back as a value\n          nextResult = storyIterator.next(failedResult);\n        }\n      } else {\n        // Everything succeeded! Reassemble the results in the original order, unwrapping each\n        // slot's EitherActionResult back to its raw value, then wrap the whole array for the\n        // caller if needed (same returnErrors logic as the single action case above).\n        const allResults = batchActionsToRun.map((ba) => ba.result?.result);\n\n        nextResult = storyIterator.next(getSuccessfulEitherActionResultIfRequired(allResults, action.returnErrors));\n      }\n\n      // Skip to the next iteration to process whatever the story yields next\n      continue;\n    }\n\n    // If we get here, this action is not overridden and not a batch.\n    // We have nothing special to do, so just yield it up to our parent (the runtime)\n    // and let it process the action normally.\n    const actionValue = yield action;\n\n    // Take whatever the runtime gave us back and pass it down to the story,\n    // so the story gets the result it was waiting for.\n    nextResult = storyIterator.next(actionValue);\n  }\n\n  // The story is done! nextResult.value is the final return value of the generator.\n  // Pass it through as our own return value.\n  return nextResult.value;\n}\n"]}

package/lib/esm/testing/configTesting.d.ts

@@ -1,10 +0,0 @@
-import { QPQConfig, QPQConfigItem } from '../config';
-export interface TestQpqConfigAppOptions {
-    applicationName?: string;
-    moduleName?: string;
-    environment?: string;
-    configRoot?: string;
-    apiBuildPath?: string;
-    feature?: string;
-}
-export declare const buildTestQpqConfig: (settings?: QPQConfigItem[], appOptions?: TestQpqConfigAppOptions) => QPQConfig;

package/lib/esm/testing/configTesting.js

@@ -1,8 +0,0 @@
-import { defineApplicationModule } from '../config';
-// Builds a QPQConfig from `settings`, prepending a default application module so context-
-// dependent selectors work. Any field of that module can be overridden via `appOptions`.
-export const buildTestQpqConfig = (settings = [], appOptions = {}) => {
-    const { applicationName = 'test-app', moduleName = 'test-module', environment = 'development', configRoot = './', apiBuildPath = './build', feature, } = appOptions;
-    return [...defineApplicationModule(applicationName, moduleName, environment, configRoot, apiBuildPath, feature), ...settings];
-};
-//# sourceMappingURL=configTesting.js.map

package/lib/esm/testing/configTesting.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"configTesting.js","sourceRoot":"","sources":["../../../src/testing/configTesting.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAwBpD,0FAA0F;AAC1F,yFAAyF;AACzF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,WAA4B,EAAE,EAAE,aAAsC,EAAE,EAAa,EAAE;IACxH,MAAM,EACJ,eAAe,GAAG,UAAU,EAC5B,UAAU,GAAG,aAAa,EAC1B,WAAW,GAAG,aAAa,EAC3B,UAAU,GAAG,IAAI,EACjB,YAAY,GAAG,SAAS,EACxB,OAAO,GACR,GAAG,UAAU,CAAC;IAEf,OAAO,CAAC,GAAG,uBAAuB,CAAC,eAAe,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC;AAChI,CAAC,CAAC","sourcesContent":["import { defineApplicationModule } from '../config';\nimport { QPQConfig, QPQConfigItem } from '../config';\n\n// ─── Config testing helper ───────────────────────────────────────────────────\n//\n// Almost every qpqCoreUtils selector needs app context — an appName setting (for\n// application/environment/feature) and a moduleName setting (for the service) — before\n// it can flatten, filter by ownership, or build fully-qualified resource names. Repeating\n// that boilerplate in each test buries the setting under test, so `buildTestQpqConfig`\n// prepends a sensible default application module and lets the caller drop in just the\n// settings the assertion is about.\n//\n//   const config = buildTestQpqConfig([defineSecret('apiKey')]);\n//   const config = buildTestQpqConfig([...], { environment: 'production', feature: 'beta' });\n\nexport interface TestQpqConfigAppOptions {\n  applicationName?: string;\n  moduleName?: string;\n  environment?: string;\n  configRoot?: string;\n  apiBuildPath?: string;\n  feature?: string;\n}\n\n// Builds a QPQConfig from `settings`, prepending a default application module so context-\n// dependent selectors work. Any field of that module can be overridden via `appOptions`.\nexport const buildTestQpqConfig = (settings: QPQConfigItem[] = [], appOptions: TestQpqConfigAppOptions = {}): QPQConfig => {\n  const {\n    applicationName = 'test-app',\n    moduleName = 'test-module',\n    environment = 'development',\n    configRoot = './',\n    apiBuildPath = './build',\n    feature,\n  } = appOptions;\n\n  return [...defineApplicationModule(applicationName, moduleName, environment, configRoot, apiBuildPath, feature), ...settings];\n};\n"]}

package/lib/esm/testing/index.d.ts

@@ -1,4 +0,0 @@
-export * from './configTesting';
-export * from './requesterTesting';
-export * from './runtimeTesting';
-export * from './storyTesting';

package/lib/esm/testing/index.js

@@ -1,5 +0,0 @@
-export * from './configTesting';
-export * from './requesterTesting';
-export * from './runtimeTesting';
-export * from './storyTesting';
-//# sourceMappingURL=index.js.map

package/lib/esm/testing/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/testing/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC","sourcesContent":["export * from './configTesting';\nexport * from './requesterTesting';\nexport * from './runtimeTesting';\nexport * from './storyTesting';\n"]}

package/lib/esm/testing/requesterTesting.d.ts

@@ -1,6 +0,0 @@
-import { Action, AskResponse, AskResponseReturnType } from '../types';
-export interface CapturedRequester<T> {
-    readonly action: Action<any>;
-    readonly returned: T;
-}
-export declare function captureRequester<T extends AskResponse<any>>(requester: T, result?: unknown): CapturedRequester<AskResponseReturnType<T>>;

package/lib/esm/testing/requesterTesting.js

@@ -1,15 +0,0 @@
-// Runs a single-action requester: pulls the one action it yields, answers with `result`,
-// and captures the value it returns. Throws if the requester yields nothing or yields
-// more than once — either means it is not a plain requester and wants a different helper.
-export function captureRequester(requester, result) {
-    const first = requester.next();
-    if (first.done) {
-        throw new Error('Expected the requester to yield an action, but it returned immediately.');
-    }
-    const second = requester.next(result);
-    if (!second.done) {
-        throw new Error('Expected the requester to complete after a single action, but it yielded again.');
-    }
-    return { action: first.value, returned: second.value };
-}
-//# sourceMappingURL=requesterTesting.js.map

package/lib/esm/testing/requesterTesting.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"requesterTesting.js","sourceRoot":"","sources":["../../../src/testing/requesterTesting.ts"],"names":[],"mappings":"AAoBA,yFAAyF;AACzF,sFAAsF;AACtF,0FAA0F;AAC1F,MAAM,UAAU,gBAAgB,CAA6B,SAAY,EAAE,MAAgB;IACzF,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;IAC/B,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,yEAAyE,CAAC,CAAC;IAC7F,CAAC;IAED,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACtC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACjB,MAAM,IAAI,KAAK,CAAC,iFAAiF,CAAC,CAAC;IACrG,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,KAAoB,EAAE,QAAQ,EAAE,MAAM,CAAC,KAAiC,EAAE,CAAC;AACpG,CAAC","sourcesContent":["import { Action, AskResponse, AskResponseReturnType } from '../types';\n\n// ─── Requester testing helper ───────────────────────────────────────────────────\n//\n// Action requesters are the simplest stories: they `yield` exactly one action and\n// `return` whatever the runtime answers with. Testing one means checking two things —\n// the shape of the action it yields, and that the runtime's response passes straight\n// through. `captureRequester` drives that single round-trip and hands both back.\n//\n//   const { action, returned } = captureRequester(askConfigGetParameter('name'), 'value');\n//   expect(action).toEqual({ type: ConfigActionType.GetParameter, payload: { parameterName: 'name' } });\n//   expect(returned).toBe('value');\n\nexport interface CapturedRequester<T> {\n  // The action the requester yielded.\n  readonly action: Action<any>;\n  // The value the requester returned after the runtime answered with `result`.\n  readonly returned: T;\n}\n\n// Runs a single-action requester: pulls the one action it yields, answers with `result`,\n// and captures the value it returns. Throws if the requester yields nothing or yields\n// more than once — either means it is not a plain requester and wants a different helper.\nexport function captureRequester<T extends AskResponse<any>>(requester: T, result?: unknown): CapturedRequester<AskResponseReturnType<T>> {\n  const first = requester.next();\n  if (first.done) {\n    throw new Error('Expected the requester to yield an action, but it returned immediately.');\n  }\n\n  const second = requester.next(result);\n  if (!second.done) {\n    throw new Error('Expected the requester to complete after a single action, but it yielded again.');\n  }\n\n  return { action: first.value as Action<any>, returned: second.value as AskResponseReturnType<T> };\n}\n"]}

package/lib/esm/testing/runtimeTesting.d.ts

@@ -1,11 +0,0 @@
-import { ActionProcessor, ActionProcessorList, ActionProcessorListResolver } from '../types/Action';
-import { QpqLogger } from '../types/QpqLogger';
-import { StorySession } from '../types/StorySession';
-export declare const TEST_TIME_NOW = "2024-01-01T00:00:00.000Z";
-export declare const getTestTimeNow: () => string;
-export declare const testRandomGuid: () => string;
-export declare const noopDynamicModuleLoader: () => Promise<null>;
-export declare const buildTestStorySession: (overrides?: Partial<StorySession>) => StorySession;
-export declare const createStubLogger: (log?: QpqLogger["log"]) => QpqLogger;
-export declare const buildActionProcessorList: (processors: Record<string, ActionProcessor<any, any>>) => ActionProcessorList;
-export declare const buildActionProcessorResolver: (processors: Record<string, ActionProcessor<any, any>>) => ActionProcessorListResolver;

package/lib/esm/testing/runtimeTesting.js

@@ -1,47 +0,0 @@
-// ─── Runtime testing toolkit ───────────────────────────────────────────────────
-//
-// The story-execution engine (processAction → resolveStory → resolveStoryWithLogs →
-// createRuntime) needs a fistful of collaborators before it will run: a logger, a caller
-// session, a clock, a guid source, a module loader, and a map of action processors. None
-// of them are interesting to any single test, so they are gathered here as tiny, explicit
-// fixtures. Tests then read as "here is the one processor I care about" plus an invoke.
-//
-//   const logger = createStubLogger(vi.fn());
-//   const result = await resolveStory(story, [], buildTestQpqConfig(), buildTestStorySession(),
-//     buildActionProcessorResolver({ [MyType]: async () => actionResult('ok') }),
-//     getTestTimeNow, logger, 'corr-1', QpqRuntimeType.UNIT_TEST, noopDynamicModuleLoader);
-// A fixed clock. resolveStory stamps startedAt/finishedAt/history with getTimeNow(), so a
-// constant makes those fields deterministic and assertable.
-export const TEST_TIME_NOW = '2024-01-01T00:00:00.000Z';
-export const getTestTimeNow = () => TEST_TIME_NOW;
-// A deterministic guid source for correlation building (`moduleName::guid`).
-export const testRandomGuid = () => 'guid-0';
-// A dynamic module loader that never resolves a module — enough for stories that do not
-// dynamically load anything.
-export const noopDynamicModuleLoader = async () => null;
-// The base caller session every runtime needs. resolveStory derives the story session from
-// it (depth + 1, inherited context/correlation), so overriding `depth` here drives the
-// depth-limit branch.
-export const buildTestStorySession = (overrides = {}) => ({
-    correlation: 'corr-0',
-    depth: 0,
-    context: {},
-    ...overrides,
-});
-// A QpqLogger whose async lifecycle hooks are no-ops. `log` is injectable so a test can
-// pass a spy (e.g. `vi.fn()`) and assert resolveStoryWithLogs called it with the result.
-export const createStubLogger = (log = () => { }) => ({
-    enableLogs: async () => { },
-    log,
-    waitToFinishWriting: async () => { },
-    moveToPermanentStorage: async () => { },
-});
-// Builds an ActionProcessorList from a plain `actionType -> processor` map. Identity with a
-// type anchor, so call sites stay terse and well-typed.
-export const buildActionProcessorList = (processors) => ({
-    ...processors,
-});
-// Wraps a processor map (or a plain map) in the resolver shape resolveStory/createRuntime
-// expect: an async function ignoring its (config, loader) args and returning the list.
-export const buildActionProcessorResolver = (processors) => async () => buildActionProcessorList(processors);
-//# sourceMappingURL=runtimeTesting.js.map

package/lib/esm/testing/runtimeTesting.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"runtimeTesting.js","sourceRoot":"","sources":["../../../src/testing/runtimeTesting.ts"],"names":[],"mappings":"AAIA,kFAAkF;AAClF,EAAE;AACF,oFAAoF;AACpF,yFAAyF;AACzF,yFAAyF;AACzF,0FAA0F;AAC1F,wFAAwF;AACxF,EAAE;AACF,8CAA8C;AAC9C,gGAAgG;AAChG,kFAAkF;AAClF,4FAA4F;AAE5F,0FAA0F;AAC1F,4DAA4D;AAC5D,MAAM,CAAC,MAAM,aAAa,GAAG,0BAA0B,CAAC;AACxD,MAAM,CAAC,MAAM,cAAc,GAAG,GAAW,EAAE,CAAC,aAAa,CAAC;AAE1D,6EAA6E;AAC7E,MAAM,CAAC,MAAM,cAAc,GAAG,GAAW,EAAE,CAAC,QAAQ,CAAC;AAErD,wFAAwF;AACxF,6BAA6B;AAC7B,MAAM,CAAC,MAAM,uBAAuB,GAAG,KAAK,IAAmB,EAAE,CAAC,IAAI,CAAC;AAEvE,2FAA2F;AAC3F,uFAAuF;AACvF,sBAAsB;AACtB,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,YAAmC,EAAE,EAAgB,EAAE,CAAC,CAAC;IAC7F,WAAW,EAAE,QAAQ;IACrB,KAAK,EAAE,CAAC;IACR,OAAO,EAAE,EAAE;IACX,GAAG,SAAS;CACb,CAAC,CAAC;AAEH,wFAAwF;AACxF,yFAAyF;AACzF,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,MAAwB,GAAG,EAAE,GAAE,CAAC,EAAa,EAAE,CAAC,CAAC;IAChF,UAAU,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC;IAC1B,GAAG;IACH,mBAAmB,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC;IACnC,sBAAsB,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC;CACvC,CAAC,CAAC;AAEH,4FAA4F;AAC5F,wDAAwD;AACxD,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,UAAqD,EAAuB,EAAE,CAAC,CAAC;IACvH,GAAG,UAAU;CACd,CAAC,CAAC;AAEH,0FAA0F;AAC1F,uFAAuF;AACvF,MAAM,CAAC,MAAM,4BAA4B,GACvC,CAAC,UAAqD,EAA+B,EAAE,CACvF,KAAK,IAAI,EAAE,CACT,wBAAwB,CAAC,UAAU,CAAC,CAAC","sourcesContent":["import { ActionProcessor, ActionProcessorList, ActionProcessorListResolver } from '../types/Action';\nimport { QpqLogger } from '../types/QpqLogger';\nimport { StorySession } from '../types/StorySession';\n\n// ─── Runtime testing toolkit ───────────────────────────────────────────────────\n//\n// The story-execution engine (processAction → resolveStory → resolveStoryWithLogs →\n// createRuntime) needs a fistful of collaborators before it will run: a logger, a caller\n// session, a clock, a guid source, a module loader, and a map of action processors. None\n// of them are interesting to any single test, so they are gathered here as tiny, explicit\n// fixtures. Tests then read as \"here is the one processor I care about\" plus an invoke.\n//\n//   const logger = createStubLogger(vi.fn());\n//   const result = await resolveStory(story, [], buildTestQpqConfig(), buildTestStorySession(),\n//     buildActionProcessorResolver({ [MyType]: async () => actionResult('ok') }),\n//     getTestTimeNow, logger, 'corr-1', QpqRuntimeType.UNIT_TEST, noopDynamicModuleLoader);\n\n// A fixed clock. resolveStory stamps startedAt/finishedAt/history with getTimeNow(), so a\n// constant makes those fields deterministic and assertable.\nexport const TEST_TIME_NOW = '2024-01-01T00:00:00.000Z';\nexport const getTestTimeNow = (): string => TEST_TIME_NOW;\n\n// A deterministic guid source for correlation building (`moduleName::guid`).\nexport const testRandomGuid = (): string => 'guid-0';\n\n// A dynamic module loader that never resolves a module — enough for stories that do not\n// dynamically load anything.\nexport const noopDynamicModuleLoader = async (): Promise<null> => null;\n\n// The base caller session every runtime needs. resolveStory derives the story session from\n// it (depth + 1, inherited context/correlation), so overriding `depth` here drives the\n// depth-limit branch.\nexport const buildTestStorySession = (overrides: Partial<StorySession> = {}): StorySession => ({\n  correlation: 'corr-0',\n  depth: 0,\n  context: {},\n  ...overrides,\n});\n\n// A QpqLogger whose async lifecycle hooks are no-ops. `log` is injectable so a test can\n// pass a spy (e.g. `vi.fn()`) and assert resolveStoryWithLogs called it with the result.\nexport const createStubLogger = (log: QpqLogger['log'] = () => {}): QpqLogger => ({\n  enableLogs: async () => {},\n  log,\n  waitToFinishWriting: async () => {},\n  moveToPermanentStorage: async () => {},\n});\n\n// Builds an ActionProcessorList from a plain `actionType -> processor` map. Identity with a\n// type anchor, so call sites stay terse and well-typed.\nexport const buildActionProcessorList = (processors: Record<string, ActionProcessor<any, any>>): ActionProcessorList => ({\n  ...processors,\n});\n\n// Wraps a processor map (or a plain map) in the resolver shape resolveStory/createRuntime\n// expect: an async function ignoring its (config, loader) args and returning the list.\nexport const buildActionProcessorResolver =\n  (processors: Record<string, ActionProcessor<any, any>>): ActionProcessorListResolver =>\n  async () =>\n    buildActionProcessorList(processors);\n"]}

package/lib/esm/testing/storyTesting.d.ts

@@ -1,22 +0,0 @@
-import { ActionOverrideMap } from '../stories/system/askOverrideActions';
-import { Action, AskResponse, AskResponseReturnType, EitherActionResult, QPQError } from '../types';
-export type ActionMock<TAction extends Action<any> = Action<any>, TResult = any> = TResult | ((action: TAction) => TResult);
-export type ActionMockMap = Record<string, ActionMock>;
-interface MockedActionError {
-    readonly __qpqMockError: true;
-    readonly errorType: string;
-    readonly errorText: string;
-    readonly errorStack?: string;
-}
-export declare const throwsError: (errorType: string, errorText: string, errorStack?: string) => MockedActionError;
-export declare class StoryError extends Error {
-    readonly errorType: string;
-    readonly errorText: string;
-    readonly errorStack?: string | undefined;
-    constructor(errorType: string, errorText: string, errorStack?: string | undefined);
-}
-export declare const mockActions: (mocks: ActionMockMap) => ActionOverrideMap;
-export declare function runStory<T extends AskResponse<any>>(story: T, mocks?: ActionMockMap): AskResponseReturnType<T>;
-export declare function expectSuccess<T>(result: EitherActionResult<T>): T;
-export declare function expectError(result: EitherActionResult<any>): QPQError;
-export {};

package/lib/esm/testing/storyTesting.js

@@ -1,100 +0,0 @@
-import { ContextActionType } from '../actions/context/ContextActionType';
-import { askThrowError } from '../actions/error/askThrowError';
-import { ErrorActionType } from '../actions/error/ErrorActionType';
-import { SystemActionType } from '../actions/system/SystemActionType';
-import { askOverrideActions, getSuccessfulEitherActionResultIfRequired } from '../stories/system/askOverrideActions';
-const isMockedActionError = (value) => typeof value === 'object' && value !== null && value.__qpqMockError === true;
-// Use as a mock value to make an action fail. Under askCatch the failure comes back as an
-// EitherActionResult; otherwise it propagates as a thrown StoryError.
-export const throwsError = (errorType, errorText, errorStack) => ({
-    __qpqMockError: true,
-    errorType,
-    errorText,
-    errorStack,
-});
-// A real story error that escaped to the runtime (an uncaught askThrowError). Carries the
-// QPQ error fields so tests can assert on them.
-export class StoryError extends Error {
-    errorType;
-    errorText;
-    errorStack;
-    constructor(errorType, errorText, errorStack) {
-        super(`${errorType}: ${errorText}`);
-        this.errorType = errorType;
-        this.errorText = errorText;
-        this.errorStack = errorStack;
-        this.name = 'StoryError';
-    }
-}
-// Turns a friendly mock map into the ActionOverrideMap askOverrideActions consumes. Each
-// handler shapes its value for returnErrors and translates `throwsError` sentinels.
-export const mockActions = (mocks) => Object.fromEntries(Object.entries(mocks).map(([actionType, mock]) => [
-    actionType,
-    function* handler(action) {
-        const value = typeof mock === 'function' ? mock(action) : mock;
-        if (isMockedActionError(value)) {
-            if (action.returnErrors) {
-                return { success: false, error: { errorType: value.errorType, errorText: value.errorText, errorStack: value.errorStack } };
-            }
-            return yield* askThrowError(value.errorType, value.errorText, value.errorStack);
-        }
-        return getSuccessfulEitherActionResultIfRequired(value, action.returnErrors);
-    },
-]));
-// Drives a story (already wrapped by askOverrideActions) to completion. Every real action
-// should be mocked, so anything that reaches the runtime is a test gap and throws — except
-// the empty batch askOverrideActions emits internally, which we answer with [].
-const drive = (story) => {
-    let next = story.next();
-    while (!next.done) {
-        const action = next.value;
-        if (action.type === SystemActionType.Batch) {
-            const subActions = action.payload?.actions ?? [];
-            if (subActions.length === 0) {
-                next = story.next(getSuccessfulEitherActionResultIfRequired([], action.returnErrors));
-                continue;
-            }
-            throw new StoryError('TestSetupError', `Unmocked action(s) in batch: ${subActions.map((a) => a.type).join(', ')}. Add them to your mocks.`);
-        }
-        if (action.type === ErrorActionType.ThrowError) {
-            const { errorType, errorText, errorStack } = action.payload;
-            if (action.returnErrors) {
-                next = story.next({ success: false, error: { errorType, errorText, errorStack } });
-                continue;
-            }
-            throw new StoryError(errorType, errorText, errorStack);
-        }
-        // An unprovided, unmocked context read resolves to the identifier's default,
-        // exactly what the production context processor does when nothing provided a
-        // value. A mock or an askContextProvideValue wrapper still takes precedence
-        // (both intercept before the action reaches the runtime).
-        if (action.type === ContextActionType.Read) {
-            next = story.next(getSuccessfulEitherActionResultIfRequired(action.payload?.contextIdentifier?.defaultValue, action.returnErrors));
-            continue;
-        }
-        throw new StoryError('TestSetupError', `Unmocked action reached the runtime: "${action.type}". Add it to your mocks.`);
-    }
-    return next.value;
-};
-// Runs a story with the given action mocks and returns its resolved value. An uncaught
-// story error (askThrowError) surfaces as a thrown StoryError.
-export function runStory(story, mocks = {}) {
-    return drive(askOverrideActions(story, mockActions(mocks)));
-}
-// Narrows a captured EitherActionResult (e.g. from askCatch) to its value, failing the
-// test loudly if it was actually an error.
-export function expectSuccess(result) {
-    if (!result.success) {
-        throw new Error(`Expected a successful result but got error: ${JSON.stringify(result.error)}`);
-    }
-    return result.result;
-}
-// Narrows a captured EitherActionResult to its error, failing the test loudly if it
-// actually succeeded.
-export function expectError(result) {
-    if (result.success) {
-        throw new Error(`Expected a failed result but got success: ${JSON.stringify(result.result)}`);
-    }
-    return result.error;
-}
-//# sourceMappingURL=storyTesting.js.map

package/lib/esm/testing/storyTesting.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"storyTesting.js","sourceRoot":"","sources":["../../../src/testing/storyTesting.ts"],"names":[],"mappings":"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","sourcesContent":["import { ContextActionType } from '../actions/context/ContextActionType';\nimport { askThrowError } from '../actions/error/askThrowError';\nimport { ErrorActionType } from '../actions/error/ErrorActionType';\nimport { SystemActionType } from '../actions/system/SystemActionType';\nimport { ActionOverrideMap, askOverrideActions, getSuccessfulEitherActionResultIfRequired } from '../stories/system/askOverrideActions';\nimport { Action, AskResponse, AskResponseReturnType, EitherActionResult, QPQError } from '../types';\n\n// ─── Story testing toolkit ─────────────────────────────────────────────────────\n//\n// Stories are generators that `yield*` actions and receive their results back. To unit\n// test one in isolation we need to stand in for the runtime and answer every action it\n// asks for. `askOverrideActions` is the production machinery that intercepts actions, so\n// we build the mocking layer on top of it: a mock map becomes an override map, and a tiny\n// driver runs the wrapped story to completion.\n//\n// The result: tests read as a few lines of mocks, an invoke, and a list of expectations.\n//\n//   const result = runStory(askThing('id'), {\n//     [KeyValueStoreActionType.Get]: { id: 'id', name: 'mock' },\n//     [DateActionType.Now]: (action) => 1000,\n//   });\n\n// A mock for a single action type. Either the raw value the action resolves to, or a\n// function of the action that computes it (handy for asserting on / varying by payload).\n// `returnErrors` wrapping (added by askCatch) is applied for you — always supply the\n// plain success value.\nexport type ActionMock<TAction extends Action<any> = Action<any>, TResult = any> = TResult | ((action: TAction) => TResult);\n\n// Maps action types (or '*' for a catch-all) to their mocks.\nexport type ActionMockMap = Record<string, ActionMock>;\n\n// Sentinel produced by `throwsError` so a mock can simulate an action that fails.\ninterface MockedActionError {\n  readonly __qpqMockError: true;\n  readonly errorType: string;\n  readonly errorText: string;\n  readonly errorStack?: string;\n}\n\nconst isMockedActionError = (value: unknown): value is MockedActionError =>\n  typeof value === 'object' && value !== null && (value as MockedActionError).__qpqMockError === true;\n\n// Use as a mock value to make an action fail. Under askCatch the failure comes back as an\n// EitherActionResult; otherwise it propagates as a thrown StoryError.\nexport const throwsError = (errorType: string, errorText: string, errorStack?: string): MockedActionError => ({\n  __qpqMockError: true,\n  errorType,\n  errorText,\n  errorStack,\n});\n\n// A real story error that escaped to the runtime (an uncaught askThrowError). Carries the\n// QPQ error fields so tests can assert on them.\nexport class StoryError extends Error {\n  constructor(\n    public readonly errorType: string,\n    public readonly errorText: string,\n    public readonly errorStack?: string,\n  ) {\n    super(`${errorType}: ${errorText}`);\n    this.name = 'StoryError';\n  }\n}\n\n// Turns a friendly mock map into the ActionOverrideMap askOverrideActions consumes. Each\n// handler shapes its value for returnErrors and translates `throwsError` sentinels.\nexport const mockActions = (mocks: ActionMockMap): ActionOverrideMap =>\n  Object.fromEntries(\n    Object.entries(mocks).map(([actionType, mock]) => [\n      actionType,\n      function* handler(action: Action<any>) {\n        const value = typeof mock === 'function' ? mock(action) : mock;\n\n        if (isMockedActionError(value)) {\n          if (action.returnErrors) {\n            return { success: false, error: { errorType: value.errorType, errorText: value.errorText, errorStack: value.errorStack } };\n          }\n          return yield* askThrowError(value.errorType, value.errorText, value.errorStack);\n        }\n\n        return getSuccessfulEitherActionResultIfRequired(value, action.returnErrors);\n      },\n    ]),\n  );\n\n// Drives a story (already wrapped by askOverrideActions) to completion. Every real action\n// should be mocked, so anything that reaches the runtime is a test gap and throws — except\n// the empty batch askOverrideActions emits internally, which we answer with [].\nconst drive = <R>(story: AskResponse<R>): R => {\n  let next = story.next();\n\n  while (!next.done) {\n    const action = next.value;\n\n    if (action.type === SystemActionType.Batch) {\n      const subActions: Action<any>[] = action.payload?.actions ?? [];\n      if (subActions.length === 0) {\n        next = story.next(getSuccessfulEitherActionResultIfRequired([], action.returnErrors));\n        continue;\n      }\n      throw new StoryError('TestSetupError', `Unmocked action(s) in batch: ${subActions.map((a) => a.type).join(', ')}. Add them to your mocks.`);\n    }\n\n    if (action.type === ErrorActionType.ThrowError) {\n      const { errorType, errorText, errorStack } = action.payload;\n      if (action.returnErrors) {\n        next = story.next({ success: false, error: { errorType, errorText, errorStack } });\n        continue;\n      }\n      throw new StoryError(errorType, errorText, errorStack);\n    }\n\n    // An unprovided, unmocked context read resolves to the identifier's default,\n    // exactly what the production context processor does when nothing provided a\n    // value. A mock or an askContextProvideValue wrapper still takes precedence\n    // (both intercept before the action reaches the runtime).\n    if (action.type === ContextActionType.Read) {\n      next = story.next(getSuccessfulEitherActionResultIfRequired(action.payload?.contextIdentifier?.defaultValue, action.returnErrors));\n      continue;\n    }\n\n    throw new StoryError('TestSetupError', `Unmocked action reached the runtime: \"${action.type}\". Add it to your mocks.`);\n  }\n\n  return next.value;\n};\n\n// Runs a story with the given action mocks and returns its resolved value. An uncaught\n// story error (askThrowError) surfaces as a thrown StoryError.\nexport function runStory<T extends AskResponse<any>>(story: T, mocks: ActionMockMap = {}): AskResponseReturnType<T> {\n  return drive(askOverrideActions(story, mockActions(mocks))) as AskResponseReturnType<T>;\n}\n\n// Narrows a captured EitherActionResult (e.g. from askCatch) to its value, failing the\n// test loudly if it was actually an error.\nexport function expectSuccess<T>(result: EitherActionResult<T>): T {\n  if (!result.success) {\n    throw new Error(`Expected a successful result but got error: ${JSON.stringify(result.error)}`);\n  }\n  return result.result;\n}\n\n// Narrows a captured EitherActionResult to its error, failing the test loudly if it\n// actually succeeded.\nexport function expectError(result: EitherActionResult<any>): QPQError {\n  if (result.success) {\n    throw new Error(`Expected a failed result but got success: ${JSON.stringify(result.result)}`);\n  }\n  return result.error;\n}\n"]}

package/lib/esm/types/utils/createActionProcessor.d.ts

@@ -1,5 +0,0 @@
-import { QPQConfig } from '../../config';
-import { ActionProcessorListResolver } from '../Action';
-import { AnyActionRequesterFunction, ProcessorFor } from '../ActionRequesterFunction';
-import { DynamicModuleLoader } from '../DynamicModuleLoader';
-export declare const createActionProcessor: <TRequester extends AnyActionRequesterFunction>(requester: TRequester, getProcessor: (qpqConfig: QPQConfig, dynamicModuleLoader: DynamicModuleLoader) => ProcessorFor<TRequester> | Promise<ProcessorFor<TRequester>>) => ActionProcessorListResolver;

package/lib/esm/types/utils/createActionProcessor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createActionProcessor.js","sourceRoot":"","sources":["../../../../src/types/utils/createActionProcessor.ts"],"names":[],"mappings":"AAKA,uFAAuF;AACvF,qFAAqF;AACrF,gEAAgE;AAChE,MAAM,CAAC,MAAM,qBAAqB,GAChC,CACE,SAAqB,EACrB,YAA8I,EACjH,EAAE,CACjC,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,EAAE,CAAC,CAAC;IACzC,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,YAAY,CAAC,SAAS,EAAE,mBAAmB,CAAC;CAC3E,CAAC,CAAC","sourcesContent":["import { QPQConfig } from '../../config';\nimport { ActionProcessorListResolver } from '../Action';\nimport { AnyActionRequesterFunction, ProcessorFor } from '../ActionRequesterFunction';\nimport { DynamicModuleLoader } from '../DynamicModuleLoader';\n\n// Builds the single-entry processor map from the requester itself, so the registration\n// key can never drift from the action type the requester yields, and the processor's\n// payload and return types are checked against the requester's.\nexport const createActionProcessor =\n  <TRequester extends AnyActionRequesterFunction>(\n    requester: TRequester,\n    getProcessor: (qpqConfig: QPQConfig, dynamicModuleLoader: DynamicModuleLoader) => ProcessorFor<TRequester> | Promise<ProcessorFor<TRequester>>,\n  ): ActionProcessorListResolver =>\n  async (qpqConfig, dynamicModuleLoader) => ({\n    [requester.actionType]: await getProcessor(qpqConfig, dynamicModuleLoader),\n  });\n"]}

package/lib/esm/types/utils/createActionRequester.d.ts

@@ -1,2 +0,0 @@
-import { ActionRequesterDefinition, ActionRequesterFunction } from '../ActionRequesterFunction';
-export declare const createActionRequester: <TReturn>() => <TType extends string, TArgs extends unknown[] = [], TPayload = undefined, TErrorTypes extends string = never>(definition: ActionRequesterDefinition<TType, TArgs, TPayload, TErrorTypes>) => ActionRequesterFunction<TType, TArgs, TPayload, TReturn, TErrorTypes>;

package/lib/esm/types/utils/createActionRequester.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createActionRequester.js","sourceRoot":"","sources":["../../../../src/types/utils/createActionRequester.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,oFAAoF;AACpF,gFAAgF;AAChF,8DAA8D;AAC9D,MAAM,CAAC,MAAM,qBAAqB,GAChC,GAAY,EAAE,CACd,CACE,UAA0E,EACH,EAAE;IACzE,kFAAkF;IAClF,+CAA+C;IAC/C,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,IAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAkC,CAAC;IAEhG,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAW;QAChC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,IAAI,CAAC,CAAC;QAEpC,+EAA+E;QAC/E,wCAAwC;QACxC,OAAO,MAAM,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,UAAU,EAAE,OAAO,EAAE,CAAC;IAClH,CAAC;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE;QAC9B,UAAU,EAAE,UAAU,CAAC,UAAU;QACjC,UAAU;QACV,SAAS,EAAE,wBAAwB,CAAC,UAAU,CAAC,UAAU,EAAE,UAAU,CAAC,UAAU,IAAI,EAAE,CAAC;KACxF,CAAC,CAAC;AACL,CAAC,CAAC","sourcesContent":["import { Action, ActionRequester } from '../Action';\nimport { ActionRequesterDefinition, ActionRequesterFunction } from '../ActionRequesterFunction';\nimport { createErrorEnumForAction } from './createErrorEnumForAction';\n\n// Curried because TypeScript has no partial type inference: the outer call pins the\n// action's return type explicitly, the inner call infers the action type, args,\n// payload shape and error catalog from the definition object.\nexport const createActionRequester =\n  <TReturn>() =>\n  <TType extends string, TArgs extends unknown[] = [], TPayload = undefined, TErrorTypes extends string = never>(\n    definition: ActionRequesterDefinition<TType, TArgs, TPayload, TErrorTypes>,\n  ): ActionRequesterFunction<TType, TArgs, TPayload, TReturn, TErrorTypes> => {\n    // Payload-less actions omit getPayload; the cast pins the stand-in builder to the\n    // defaulted TArgs = [] / TPayload = undefined.\n    const getPayload = definition.getPayload ?? ((() => undefined) as (...args: TArgs) => TPayload);\n\n    function* askAction(...args: TArgs): ActionRequester<Action<TPayload> & { type: TType }, TReturn> {\n      const payload = getPayload(...args);\n\n      // Payload-less actions yield { type } with no payload key at all, matching the\n      // hand-written requester shape exactly.\n      return yield payload === undefined ? { type: definition.actionType } : { type: definition.actionType, payload };\n    }\n\n    return Object.assign(askAction, {\n      actionType: definition.actionType,\n      getPayload,\n      errorType: createErrorEnumForAction(definition.actionType, definition.errorTypes ?? []),\n    });\n  };\n"]}

package/lib/esm/types/utils/createErrorEnumForAction.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createErrorEnumForAction.js","sourceRoot":"","sources":["../../../../src/types/utils/createErrorEnumForAction.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,wBAAwB,CAAC,IAAY,EAAE,KAAa;IAClE,OAAO,GAAG,IAAI,IAAI,KAAK,EAAE,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAmB,IAAY,EAAE,MAAW;IAClF,kFAAkF;IAClF,+EAA+E;IAC/E,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAC7B,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;QACb,GAAG,CAAC,KAAK,CAAC,GAAG,wBAAwB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACnD,OAAO,GAAG,CAAC;IACb,CAAC,EACD,MAAM,CAAC,MAAM,CAAC,IAAI,CAAyB,CAC5C,CAAC;IAEF,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["export function createErrorTypeEnumValue(base: string, error: string): string {\n  return `${base}-${error}`;\n}\n\nexport function createErrorEnumForAction<T extends string>(base: string, values: T[]): { [K in T]: string } {\n  // Null prototype so every value lands as an own property. On a plain object a key\n  // like \"__proto__\" would hit the prototype setter and silently drop the entry.\n  const errorEnum = values.reduce(\n    (acc, value) => {\n      acc[value] = createErrorTypeEnumValue(base, value);\n      return acc;\n    },\n    Object.create(null) as { [K in T]: string },\n  );\n\n  return errorEnum;\n}\n"]}

package/lib/esm/types/utils/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/types/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC","sourcesContent":["export * from './createActionProcessor';\nexport * from './createActionRequester';\nexport * from './createErrorEnumForAction';\n"]}

package/lib/esm/utils/types/index.d.ts

@@ -1,2 +0,0 @@
-export * from './isDefined';
-export * from './when';

package/lib/esm/utils/types/index.js

@@ -1,3 +0,0 @@
-export * from './isDefined';
-export * from './when';
-//# sourceMappingURL=index.js.map

package/lib/esm/utils/types/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/utils/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC","sourcesContent":["export * from './isDefined';\nexport * from './when';\n"]}

package/lib/esm/utils/types/isDefined.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isDefined.js","sourceRoot":"","sources":["../../../../src/utils/types/isDefined.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,SAAS,CAAI,CAAuB;IAClD,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,CAAC;AACvC,CAAC","sourcesContent":["export function isDefined<T>(v: T | null | undefined): v is T {\n  return v !== null && v !== undefined;\n}\n"]}

package/lib/esm/utils/types/when.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"when.js","sourceRoot":"","sources":["../../../../src/utils/types/when.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,IAAI,CAAmB,SAAkB,EAAE,KAAQ,EAAE,QAAY;IAC/E,OAAO,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAE,QAAc,CAAC;AAC7C,CAAC","sourcesContent":["export function when<T, F = undefined>(condition: unknown, value: T, fallback?: F): T | F {\n  return condition ? value : (fallback as F);\n}\n"]}