velocious 1.0.449 → 1.0.451

package/src/testing/test-files-finder.js

@@ -39,42 +39,42 @@ export default class TestFilesFinder {
 
     /**
      * Narrows the runtime value to the documented type.
-      @type {string[]} */
+     * @type {string[]} */
     this.foundFiles = []
 
     /**
      * Narrows the runtime value to the documented type.
-      @type {Record<number, Promise<void>>} */
+     * @type {Record<number, Promise<void>>} */
     this.findingPromises = {}
 
     /**
      * Narrows the runtime value to the documented type.
-      @type {string[]} */
+     * @type {string[]} */
     this.testArgs = this.processArgs.filter((processArg, index) => index != 0)
 
     /**
      * Narrows the runtime value to the documented type.
-      @type {string[]} */
+     * @type {string[]} */
     this.directoryArgs = []
 
     /**
      * Narrows the runtime value to the documented type.
-      @type {string[]} */
+     * @type {string[]} */
     this.directoryFullPaths = []
 
     /**
      * Narrows the runtime value to the documented type.
-      @type {string[]} */
+     * @type {string[]} */
     this.fileArgs = []
 
     /**
      * Narrows the runtime value to the documented type.
-      @type {string[]} */
+     * @type {string[]} */
     this.explicitFiles = []
 
     /**
      * Narrows the runtime value to the documented type.
-      @type {Record<string, number[]>} */
+     * @type {Record<string, number[]>} */
     this.lineFiltersByFile = {}
 
     this._argsPrepared = false

package/src/testing/test-filter-parser.js

@@ -74,11 +74,11 @@ export function parseFilters(processArgs) {
 
   /**
    * Defines groups.
-    @type {number | undefined} */
+   * @type {number | undefined} */
   let groups
   /**
    * Defines groupNumber.
-    @type {number | undefined} */
+   * @type {number | undefined} */
   let groupNumber
 
   let inRestArgs = false

package/src/testing/test-runner.js

@@ -39,11 +39,11 @@ function runWithTimeout(promise, timeoutMs, testDescription) {
 
 /**
  * ConsoleMethodName type.
-  @typedef {"log" | "info" | "warn" | "error" | "debug"} ConsoleMethodName */
+ * @typedef {"log" | "info" | "warn" | "error" | "debug"} ConsoleMethodName */
 
 /**
  * Captured console methods.
-  @type {ConsoleMethodName[]} */
+ * @type {ConsoleMethodName[]} */
 const CAPTURED_CONSOLE_METHODS = ["log", "info", "warn", "error", "debug"]
 
 /**
@@ -149,12 +149,12 @@ function toFileSlug(value) {
 export default class TestRunner {
   /**
    * Narrows the runtime value to the documented type.
-    @type {ActiveAfterAllScopeEntry[]} */
+   * @type {ActiveAfterAllScopeEntry[]} */
   _activeAfterAllScopes
 
   /**
    * Narrows the runtime value to the documented type.
-    @type {FailedTestDetail[]} */
+   * @type {FailedTestDetail[]} */
   _failedTestDetails
 
   /**
@@ -343,7 +343,7 @@ export default class TestRunner {
   getExcludeTagSet() {
     /**
      * Config tags.
-      @type {string[]} */
+     * @type {string[]} */
     const configTags = Array.isArray(testConfig.excludeTags) ? testConfig.excludeTags : []
 
     return new Set([...this._excludeTags, ...configTags])
@@ -379,7 +379,7 @@ export default class TestRunner {
       const testData = tests.tests[testDescription]
       const testArgs = /**
                         * Narrows the runtime value to the documented type.
-                         @type {TestArgs} */ (Object.assign({}, testData.args))
+                        * @type {TestArgs} */ (Object.assign({}, testData.args))
       const includeByLine = lineMatchedInScope || this.matchesLineFilter(testData)
 
       if (this._onlyFocussed && !testArgs.focus) continue
@@ -719,7 +719,7 @@ export default class TestRunner {
 
     if (!shouldRunAnyTests) return
 
-    /** Scope entry. @type {ActiveAfterAllScopeEntry} */
+    /** @type {ActiveAfterAllScopeEntry} */
     const scopeEntry = {tests, afterAllsRun: false}
     this._activeAfterAllScopes.push(scopeEntry)
 
@@ -732,7 +732,7 @@ export default class TestRunner {
         const testData = tests.tests[testDescription]
         const testArgs = /**
                           * Narrows the runtime value to the documented type.
-                           @type {TestArgs} */ (Object.assign({}, testData.args))
+                          * @type {TestArgs} */ (Object.assign({}, testData.args))
         const includeByLine = scopeLineMatch || this.matchesLineFilter(testData)
 
         if (this._onlyFocussed && !testArgs.focus) continue
@@ -757,7 +757,7 @@ export default class TestRunner {
         let attemptNumber = 1
         /**
          * Attempt console outputs.
-          @type {AttemptConsoleOutput[]} */
+         * @type {AttemptConsoleOutput[]} */
         const attemptConsoleOutputs = []
 
         console.log(`${leftPadding}it ${testDescription}`)
@@ -766,15 +766,15 @@ export default class TestRunner {
           let shouldRetry = false
           /**
            * Defines caughtError.
-            @type {?} */
+           * @type {?} */
           let caughtError
           /**
            * Defines failedError.
-            @type {?} */
+           * @type {?} */
           let failedError
           /**
            * Defines lastError.
-            @type {?} */
+           * @type {?} */
           let lastError
           let willRetry = false
           const stopConsoleCapture = this.startConsoleCapture({
@@ -1120,17 +1120,17 @@ export default class TestRunner {
   startConsoleCapture({passthrough = false} = {}) {
     /**
      * Lines.
-      @type {string[]} */
+     * @type {string[]} */
     const lines = []
     /**
      * Console object.
-      @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */
+     * @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */
     const consoleObject = /**
                            * Narrows the runtime value to the documented type.
-                            @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */ (console)
+                           * @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */ (console)
     /**
      * Original console methods.
-      @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */
+     * @type {Record<ConsoleMethodName, (...args: Array<?>) => void>} */
     const originalConsoleMethods = {
       debug: consoleObject.debug.bind(console),
       error: consoleObject.error.bind(console),

package/src/testing/test-suite-splitter.js

@@ -140,7 +140,7 @@ export default class TestSuiteSplitter {
   distributeGreedily(sortedFiles) {
     /**
      * Buckets.
-      @type {GroupBucket[]} */
+     * @type {GroupBucket[]} */
     const buckets = []
 
     for (let i = 0; i < this._groups; i++) {

package/src/testing/test.js

@@ -8,25 +8,25 @@ import {arrayContaining, objectContaining} from "./expect-utils.js"
 
 /**
  * Tests.
-  @type {import("./test-runner.js").TestsArgument} */
+ * @type {import("./test-runner.js").TestsArgument} */
 const tests = {
   /**
    * Narrows the runtime value to the documented type.
-    @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
+   * @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
   afterEaches: [],
   /**
    * Narrows the runtime value to the documented type.
-    @type {import("./test-runner.js").BeforeAfterAllCallbackObjectType[]} */
+   * @type {import("./test-runner.js").BeforeAfterAllCallbackObjectType[]} */
   afterAlls: [],
   args: {},
 
   /**
    * Narrows the runtime value to the documented type.
-    @type {import("./test-runner.js").BeforeAfterAllCallbackObjectType[]} */
+   * @type {import("./test-runner.js").BeforeAfterAllCallbackObjectType[]} */
   beforeAlls: [],
   /**
    * Narrows the runtime value to the documented type.
-    @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
+   * @type {import("./test-runner.js").AfterBeforeEachCallbackObjectType[]} */
   beforeEaches: [],
   filePath: undefined,
   line: undefined,
@@ -99,7 +99,7 @@ function normalizeTags(tags) {
 
 /**
  * Test config.
-  @type {VelociousTestConfig} */
+ * @type {VelociousTestConfig} */
 const testConfig = {
   consoleOutput: "failure",
   failedConsoleOutputMaxLines: 200,
@@ -212,7 +212,7 @@ function afterAll(callback) {
 async function describe(description, arg1, arg2) {
   /**
    * Defines testArgs.
-    @type {Record<string, ?>} */
+   * @type {Record<string, ?>} */
   let testArgs, testFunction
 
   if (typeof arg2 == "function") {
@@ -278,23 +278,23 @@ function it(description, arg1, arg2) {
   const currentTest = currentPath[currentPath.length - 1]
   /**
    * Defines testArgs.
-    @type {Record<string, ?>} */
+   * @type {Record<string, ?>} */
   let testArgs
 
   /**
    * Defines testFunction.
-    @type {() => (void|Promise<void>)} */
+   * @type {() => (void|Promise<void>)} */
   let testFunction
 
   if (typeof arg1 == "function") {
     testFunction = /**
                     * Narrows the runtime value to the documented type.
-                     @type {() => (void|Promise<void>)} */ (arg1)
+                    * @type {() => (void|Promise<void>)} */ (arg1)
     testArgs = {}
   } else if (typeof arg2 == "function") {
     testFunction = /**
                     * Narrows the runtime value to the documented type.
-                     @type {() => (void|Promise<void>)} */ (arg2)
+                    * @type {() => (void|Promise<void>)} */ (arg2)
     testArgs = arg1
   } else {
     throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)
@@ -322,23 +322,23 @@ function it(description, arg1, arg2) {
 function fit(description, arg1, arg2) {
   /**
    * Defines testArgs.
-    @type {Record<string, ?>} */
+   * @type {Record<string, ?>} */
   let testArgs
 
   /**
    * Defines testFunction.
-    @type {() => (void|Promise<void>)} */
+   * @type {() => (void|Promise<void>)} */
   let testFunction
 
   if (typeof arg1 == "function") {
     testFunction = /**
                     * Narrows the runtime value to the documented type.
-                     @type {() => (void|Promise<void>)} */ (arg1)
+                    * @type {() => (void|Promise<void>)} */ (arg1)
     testArgs = {focus: true}
   } else if (typeof arg2 == "function") {
     testFunction = /**
                     * Narrows the runtime value to the documented type.
-                     @type {() => (void|Promise<void>)} */ (arg2)
+                    * @type {() => (void|Promise<void>)} */ (arg2)
     testArgs = Object.assign({focus: true}, arg1)
   } else {
     throw new Error(`Invalid arguments for it: ${description}, ${arg1}`)

package/src/utils/backtrace-cleaner.js

@@ -107,7 +107,7 @@ function relativeApplicationPath(sourcePath, applicationDirectory) {
 export default class BacktraceCleaner {
   /**
    * Framework source directory.
-    @type {string | undefined} */
+   * @type {string | undefined} */
   frameworkSourceDirectory = undefined
 
   /**

package/src/utils/format-value.js

@@ -51,7 +51,7 @@ function minifiedStringify(value) {
 
     /**
      * Output.
-      @type {Record<string, ?>} */
+     * @type {Record<string, ?>} */
     const output = {}
 
     for (const key of Object.keys(current)) {

package/src/utils/model-scope.js

@@ -52,5 +52,5 @@ export function defineModelScope({callback, modelClass, startQuery}) {
 export function isModelScopeDescriptor(value) {
   return Boolean(value && typeof value === "object" && /**
                                                         * Narrows the runtime value to the documented type.
-                                                         @type {Record<string, ?>} */ (value)[MODEL_SCOPE_DESCRIPTOR_MARKER] === true)
+                                                        * @type {Record<string, ?>} */ (value)[MODEL_SCOPE_DESCRIPTOR_MARKER] === true)
 }

package/src/utils/ransack.js

@@ -81,7 +81,7 @@ export function normalizeRansackGroup(modelClass, params) {
 
   /**
    * Normalized.
-    @type {RansackGroup} */
+   * @type {RansackGroup} */
   const normalized = {
     combinator: normalizeRansackCombinator(params.m, "and"),
     conditions: [],
@@ -154,7 +154,7 @@ function normalizeSimpleRansackCondition({key, modelClass, rawValue}) {
 function normalizeAdvancedRansackConditions({modelClass, value}) {
   /**
    * Conditions.
-    @type {RansackCondition[]} */
+   * @type {RansackCondition[]} */
   const conditions = []
 
   for (const entry of normalizeRansackCollection(value, "conditions")) {
@@ -174,7 +174,7 @@ function normalizeAdvancedRansackConditions({modelClass, value}) {
 
     const predicate = /**
                        * Narrows the runtime value to the documented type.
-                        @type {RansackPredicate} */ (predicateValue)
+                       * @type {RansackPredicate} */ (predicateValue)
     const rawValue = advancedRansackConditionValue({predicate, value: entry.v})
     const normalizedValue = normalizeRansackValue({predicate, value: rawValue})
 
@@ -203,7 +203,7 @@ function normalizeAdvancedRansackConditions({modelClass, value}) {
 function normalizeAdvancedRansackGroups({modelClass, value}) {
   /**
    * Groupings.
-    @type {RansackGroup[]} */
+   * @type {RansackGroup[]} */
   const groupings = []
 
   for (const entry of normalizeRansackCollection(value, "groupings")) {
@@ -286,7 +286,7 @@ function resolveRansackAttributesFromAdvancedValue({modelClass, value}) {
   const values = normalizeAdvancedAttributeValues(value)
   /**
    * Attributes.
-    @type {RansackAttribute[]} */
+   * @type {RansackAttribute[]} */
   const attributes = []
 
   for (const attributeValue of values) {
@@ -391,7 +391,7 @@ function modelClassAtPath({modelClass, path}) {
 function resolveRansackPath({modelClass, value}) {
   /**
    * Path.
-    @type {string[]} */
+   * @type {string[]} */
   const path = []
   let currentModelClass = modelClass
   let remainingValue = value
@@ -525,16 +525,16 @@ function resolveAttributeName({modelClass, value}) {
 function relationshipEntries(modelClass) {
   if (typeof /**
               * Narrows the runtime value to the documented type.
-               @type {?} */ (modelClass).getRelationshipsMap === "function") {
+              * @type {?} */ (modelClass).getRelationshipsMap === "function") {
     return backendRelationshipEntries(modelClass)
   }
 
   if (typeof /**
               * Narrows the runtime value to the documented type.
-               @type {?} */ (modelClass).relationshipDefinitions === "function" &&
+              * @type {?} */ (modelClass).relationshipDefinitions === "function" &&
     typeof /**
             * Narrows the runtime value to the documented type.
-             @type {?} */ (modelClass).relationshipModelClasses === "function") {
+            * @type {?} */ (modelClass).relationshipModelClasses === "function") {
     return frontendRelationshipEntries(modelClass)
   }
 
@@ -549,11 +549,11 @@ function relationshipEntries(modelClass) {
 function backendRelationshipEntries(modelClass) {
   /**
    * Entries.
-    @type {Record<string, {targetModelClass: RansackModelClass}>} */
+   * @type {Record<string, {targetModelClass: RansackModelClass}>} */
   const entries = {}
   const relationshipsMap = /**
                             * Narrows the runtime value to the documented type.
-                             @type {?} */ (modelClass).getRelationshipsMap()
+                            * @type {?} */ (modelClass).getRelationshipsMap()
 
   for (const relationshipName of Object.keys(relationshipsMap)) {
     const relationship = relationshipsMap[relationshipName]
@@ -578,14 +578,14 @@ function backendRelationshipEntries(modelClass) {
 function frontendRelationshipEntries(modelClass) {
   /**
    * Entries.
-    @type {Record<string, {targetModelClass: RansackModelClass}>} */
+   * @type {Record<string, {targetModelClass: RansackModelClass}>} */
   const entries = {}
   const definitions = /**
                        * Narrows the runtime value to the documented type.
-                        @type {?} */ (modelClass).relationshipDefinitions()
+                       * @type {?} */ (modelClass).relationshipDefinitions()
   const relationshipModelClasses = /**
                                     * Narrows the runtime value to the documented type.
-                                     @type {?} */ (modelClass).relationshipModelClasses()
+                                    * @type {?} */ (modelClass).relationshipModelClasses()
 
   for (const relationshipName of Object.keys(definitions)) {
     const targetModelClass = resolveFrontendModelClass(relationshipModelClasses[relationshipName])
@@ -606,23 +606,23 @@ function frontendRelationshipEntries(modelClass) {
 function attributeEntries(modelClass) {
   if (typeof /**
               * Narrows the runtime value to the documented type.
-               @type {?} */ (modelClass).getAttributeNameToColumnNameMap === "function") {
-    return /** Narrows the runtime value to the documented type. @type {Record<string, string>} */ ((/**
-                                                                                                      * Narrows the runtime value to the documented type.
-                                                                                                       @type {?} */ (modelClass).getAttributeNameToColumnNameMap()))
+              * @type {?} */ (modelClass).getAttributeNameToColumnNameMap === "function") {
+    return /** @type {Record<string, string>} */ ((/**
+                                                    * Narrows the runtime value to the documented type.
+                                                    * @type {?} */ (modelClass).getAttributeNameToColumnNameMap()))
   }
 
   const resourceConfig = typeof /**
                                  * Narrows the runtime value to the documented type.
-                                  @type {?} */ (modelClass).resourceConfig === "function"
+                                 * @type {?} */ (modelClass).resourceConfig === "function"
     ? /**
        * Narrows the runtime value to the documented type.
-        @type {?} */ (modelClass).resourceConfig()
+       * @type {?} */ (modelClass).resourceConfig()
     : {}
   const attributes = resourceConfig.attributes
   /**
    * Entries.
-    @type {Record<string, string>} */
+   * @type {Record<string, string>} */
   const entries = {}
 
   if (Array.isArray(attributes)) {
@@ -677,7 +677,7 @@ function parseRansackKey(key) {
       pathValue,
       predicate: /**
                   * Narrows the runtime value to the documented type.
-                   @type {RansackPredicate} */ (predicate)
+                  * @type {RansackPredicate} */ (predicate)
     }
   }
 
@@ -696,7 +696,7 @@ function parseRansackKey(key) {
       pathValue,
       predicate: /**
                   * Narrows the runtime value to the documented type.
-                   @type {RansackPredicate} */ (predicate)
+                  * @type {RansackPredicate} */ (predicate)
     }
   }
 
@@ -759,11 +759,11 @@ function normalizeRansackListValue(value) {
 
 /**
  * Ransack true values.
-  @type {Set<?>} */
+ * @type {Set<?>} */
 const ransackTrueValues = new Set([true, 1, "1", "true"])
 /**
  * Ransack false values.
-  @type {Set<?>} */
+ * @type {Set<?>} */
 const ransackFalseValues = new Set([false, 0, "0", "false"])
 
 /**
@@ -825,7 +825,7 @@ export function parseRansackSort(modelClass, sortString) {
 
   /**
    * Sorts.
-    @type {RansackSort[]} */
+   * @type {RansackSort[]} */
   const sorts = []
 
   for (const segment of segments) {

package/src/utils/with-tracked-stack-async-hooks.js

@@ -4,15 +4,15 @@ import {AsyncLocalStorage} from "node:async_hooks"
 
 /**
  * Defines asyncLocalStorage.
-  @type {import("node:async_hooks").AsyncLocalStorage<Array<string[]>> | undefined} */
+ * @type {import("node:async_hooks").AsyncLocalStorage<Array<string[]>> | undefined} */
 let asyncLocalStorage
 
 /**
  * Tracked stack global.
-  @type {{withTrackedStack?: {addTrackedStackToError: (error: Error) => void, withTrackedStack: (arg1: string | (() => Promise<?>), arg2?: (() => Promise<?>) | Error) => Promise<?>}}} */
+ * @type {{withTrackedStack?: {addTrackedStackToError: (error: Error) => void, withTrackedStack: (arg1: string | (() => Promise<?>), arg2?: (() => Promise<?>) | Error) => Promise<?>}}} */
 const trackedStackGlobal = /**
                             * Narrows the runtime value to the documented type.
-                             @type {?} */ (globalThis)
+                            * @type {?} */ (globalThis)
 
 if (AsyncLocalStorage) {
   asyncLocalStorage = new AsyncLocalStorage()
@@ -48,23 +48,23 @@ function addTrackedStackToError(error) {
 async function withTrackedStack(arg1, arg2) {
   /**
    * Defines callback.
-    @type {() => Promise<?>} */
+   * @type {() => Promise<?>} */
   let callback
 
   /**
    * Defines stack.
-    @type {string} */
+   * @type {string} */
   let stack
 
   if (typeof arg2 == "function" && typeof arg1 == "string") {
     callback = /**
                 * Narrows the runtime value to the documented type.
-                 @type {() => Promise<?>} */ (arg2)
+                * @type {() => Promise<?>} */ (arg2)
     stack = arg1
   } else {
     callback = /**
                 * Narrows the runtime value to the documented type.
-                 @type {() => Promise<?>} */ (arg1)
+                * @type {() => Promise<?>} */ (arg1)
     stack = Error().stack || ""
   }
 

package/src/utils/with-tracked-stack.js

@@ -2,10 +2,10 @@
 
 /**
  * Tracked stack global.
-  @type {{withTrackedStack?: {withTrackedStack?: (stack: string | undefined, fn: () => Promise<?>) => Promise<?>, addTrackedStackToError?: (error: Error) => void}}} */
+ * @type {{withTrackedStack?: {withTrackedStack?: (stack: string | undefined, fn: () => Promise<?>) => Promise<?>, addTrackedStackToError?: (error: Error) => void}}} */
 const trackedStackGlobal = /**
                             * Narrows the runtime value to the documented type.
-                             @type {?} */ (globalThis)
+                            * @type {?} */ (globalThis)
 
 /**
  * Runs add tracked stack to error.
@@ -25,7 +25,7 @@ async function withTrackedStack(stackOrCallback, callback) {
   const tracked = trackedStackGlobal.withTrackedStack?.withTrackedStack
   const resolvedCallback = callback ?? /**
                                         * Narrows the runtime value to the documented type.
-                                         @type {() => Promise<?>} */ (stackOrCallback)
+                                        * @type {() => Promise<?>} */ (stackOrCallback)
   const stack = typeof stackOrCallback == "string" ? stackOrCallback : undefined
 
   if (tracked) {