@serenity-js/core 3.23.2 → 3.24.1

package/src/screenplay/questions/List.ts

@@ -16,7 +16,7 @@ import { ExpectationMet } from './expectations';
  *
  * @group Questions
  */
-export abstract class List<Item_Type> extends Question<Promise<Item_Type[]>> {
+export abstract class List<Item_Type> extends Question<Promise<Array<Item_Type>>> {
     protected subject?: string;
 
     static of<IT, CT, RQT extends (Question<Promise<Array<IT>>> | Question<Array<IT>>)>(collection: Answerable<Array<IT>> & ChainableMetaQuestion<CT, RQT>): MetaList<CT, IT>;
@@ -30,7 +30,7 @@ export abstract class List<Item_Type> extends Question<Promise<Item_Type[]>> {
     }
 
     constructor(protected readonly collection: Answerable<Array<Item_Type>>) {
-        super();
+        super(d`${ collection }`);
     }
 
     forEach(callback: (current: CurrentItem<Item_Type>, index: number, items: Array<Item_Type>) => Promise<void> | void): Task {
@@ -64,15 +64,6 @@ export abstract class List<Item_Type> extends Question<Promise<Item_Type[]>> {
         return collection;
     }
 
-    describedAs(subject: string): this {
-        this.subject = subject;
-        return this;
-    }
-
-    toString(): string {
-        return this.subject ?? d`${ this.collection }`;
-    }
-
     /**
      * @param {number} index
      */
@@ -287,21 +278,17 @@ export class MetaList<Supported_Context_Type, Item_Type>
 class Where<Item_Type, Answer_Type>
     extends Question<Promise<Array<Item_Type>>>
 {
-    private subject: string;
-
     constructor(
         protected readonly collection: Answerable<Array<Item_Type>>,
         protected readonly question: MetaQuestion<Item_Type, Question<Promise<Answer_Type> | Answer_Type>>,
         protected readonly expectation: Expectation<Answer_Type>,
         originalSubject: string,
     ) {
-        super();
-
-        const prefix = this.collection instanceof Where
+        const prefix = collection instanceof Where
             ? ' and'
             : ' where';
 
-        this.subject = originalSubject + prefix + d` ${ question } does ${ expectation }`;
+        super(originalSubject + prefix + d` ${ question } does ${ expectation }`);
     }
 
     async answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<Array<Item_Type>> {
@@ -319,19 +306,11 @@ class Where<Item_Type, Answer_Type>
             }
 
             return results;
-        } catch (error) {
+        }
+        catch (error) {
             throw new LogicError(d`Couldn't check if ${ this.question } of an item of ${ this.collection } does ${ this.expectation }: ` + error.message, error);
         }
     }
-
-    describedAs(subject: string): this {
-        this.subject = subject;
-        return this;
-    }
-
-    toString(): string {
-        return this.subject;
-    }
 }
 
 /**
@@ -356,16 +335,12 @@ class MetaWhere<Supported_Context_Type, Item_Type, Answer_Type>
  */
 class EachMappedTo<Item_Type, Mapped_Item_Type> extends Question<Promise<Array<Mapped_Item_Type>>> {
 
-    private subject: string;
-
     constructor(
         protected readonly collection: Answerable<Array<Item_Type>>,
         protected readonly mapping: MetaQuestion<Item_Type, Question<Promise<Mapped_Item_Type> | Mapped_Item_Type>>,
         originalSubject: string,
     ) {
-        super();
-
-        this.subject = originalSubject + d` mapped to ${ this.mapping }`;
+        super(originalSubject + d` mapped to ${ mapping }`);
     }
 
     async answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<Array<Mapped_Item_Type>> {
@@ -379,15 +354,6 @@ class EachMappedTo<Item_Type, Mapped_Item_Type> extends Question<Promise<Array<M
 
         return mapped;
     }
-
-    describedAs(subject: string): this {
-        this.subject = subject;
-        return this;
-    }
-
-    toString(): string {
-        return this.subject;
-    }
 }
 
 /**

package/src/screenplay/questions/Unanswered.ts

@@ -14,6 +14,10 @@ import * as util from 'util';   // eslint-disable-line unicorn/import-style
  * @group Questions
  */
 export class Unanswered extends TinyType {
+    static isUnanswered(value: unknown): value is Unanswered {
+        return value instanceof Unanswered;
+    }
+
     [util.inspect.custom](): string {
         return `<<unanswered>>`;
     }

package/src/screenplay/questions/expectations/ExpectationDetails.ts

@@ -1,7 +1,7 @@
 import type { JSONObject, JSONValue} from 'tiny-types';
 import { ensure, isArray, isDefined, TinyType } from 'tiny-types';
 
-import { inspected, typeOf } from '../../../io';
+import { inspected, ValueInspector } from '../../../io';
 import { Name } from '../../../model';
 import { Unanswered } from '../Unanswered';
 
@@ -55,7 +55,7 @@ export class ExpectationDetails extends TinyType {
         return {
             name: this.name.value,
             args: this.args.map(arg => ({
-                type: typeOf(arg),
+                type: ValueInspector.typeOf(arg),
                 value: arg['toJSON']
                     ? (arg as any).toJSON()
                     : arg,

package/src/screenplay/questions/index.ts

@@ -1,10 +1,12 @@
 export * from './AnswersQuestions';
 export * from './ChainableMetaQuestion';
 export * from './Check';
+export * from './Describable';
+export * from './DescriptionFormattingOptions';
 export * from './Expectation';
 export * from './expectations';
 export * from './List';
 export * from './Masked';
 export * from './MetaQuestion';
-export * from './q';
+export * from './tag-functions';
 export * from './Unanswered';

package/src/screenplay/questions/tag-functions.ts

@@ -0,0 +1,313 @@
+import { asyncMap, ValueInspector } from '../../io';
+import type { UsesAbilities } from '../abilities';
+import type { Answerable } from '../Answerable';
+import type { MetaQuestionAdapter, QuestionAdapter } from '../Question';
+import { Question } from '../Question';
+import type { AnswersQuestions } from './AnswersQuestions';
+import { Describable } from './Describable';
+import type { DescriptionFormattingOptions } from './DescriptionFormattingOptions';
+import type { MetaQuestion } from './MetaQuestion';
+
+/**
+ * Creates a single-line description of an {@apilink Activity} by transforming
+ * a [template literal](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#Tagged_templates),
+ * parameterised with [primitive data types](https://developer.mozilla.org/en-US/docs/Glossary/Primitive),
+ * [complex data structures](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#objects),
+ * or any other {@apilink Answerable|Answerables}, into a {@link QuestionAdapter|`QuestionAdapter<string>`}
+ * that can be used with {@apilink Task.where} and {@apilink Interaction.where} methods.
+ *
+ * ```ts
+ * const dial = (phoneNumber: Answerable<string>) =>
+ *  Task.where(the `#actor dials ${ phoneNumber }`, /* *\/)
+ *
+ * await actorCalled('Alice').attemptsTo(
+ *   dial('(555) 123-4567'),
+ *   // reported as: Alice dials "(555) 123-4567"
+ * )
+ * ```
+ *
+ * ## Trimming the output
+ *
+ * Use {@apilink DescriptionFormattingOptions} to trim the descriptions of template parameters.
+ * By default, the output is displayed in full.
+ *
+ * ```ts
+ * import { actorCalled, Task, the } from '@serenity-js/core'
+ *
+ * const dial = (phoneNumber: Answerable<string>) =>
+ *  Task.where(dial({ maxLength: 10 }) `#actor dials ${ phoneNumber }`, /* *\/)
+ *
+ * await actorCalled('Alice').attemptsTo(
+ *   dial('(555) 123-4567'),
+ *   // reported as: Alice dials "(555) 123-...'
+ * )
+ * ```
+ *
+ * ## Using with Questions
+ *
+ * When `the` is parameterised with {@apilink Question|Questions},
+ * it retrieves their description by calling {@apilink Question.describedBy}
+ * in the context of the {@apilink Actor} performing the {@apilink Activity}.
+ * 
+ * ```ts
+ * import { actorCalled, Question, Task, the } from '@serenity-js/core'
+ *
+ * const phoneNumber = (areaCode: string, centralOfficeCode: string, lineNumber: string) =>
+ *  Question.about('phone number', actor => {
+ *     return `(${ this.areaCode }) ${ this.centralOfficeCode }-${ this.lineNumber }`
+ *   })
+ * 
+ * const dial = (phoneNumber: Answerable<string>) =>
+ *  Task.where(dial({ maxLength: 10 }) `#actor dials ${ phoneNumber }`, /* *\/)
+ *
+ * await actorCalled('Alice').attemptsTo(
+ *   dial(phoneNumber('555', '123', '4567'),
+ *   // reported as: Alice dials phone number
+ * )
+ * ```
+ * 
+ * If you'd like the question to be described using its formatted value instead of its description, use {@apilink Question.formattedValue}.
+ *
+ * ```ts
+ * import { actorCalled, Question, Task, the } from '@serenity-js/core'
+ *
+ * const phoneNumber = (areaCode: string, centralOfficeCode: string, lineNumber: string) =>
+ *   Question.about('phone number', actor => {
+ *     return `(${ this.areaCode }) ${ this.centralOfficeCode }-${ this.lineNumber }`
+ *   }).describedAs(Question.formattedValue())
+ *
+ * const dial = (phoneNumber: Answerable<string>) =>
+ *  Task.where(dial({ maxLength: 10 }) `#actor dials ${ phoneNumber }`, /* *\/)
+ *
+ * await actorCalled('Alice').attemptsTo(
+ *   dial(phoneNumber('555', '123', '4567'),
+ *   // reported as: Alice dials "(555) 123-4567"
+ * )
+ * ```
+ *
+ * ## Using with objects with a custom `toString` method
+ *
+ * When `the` is parameterised with objects that have
+ * a custom [`toString()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString) method,
+ * or {@link Answerable|Answerables} resolving to such objects, the `toString()` method is called to produce the resulting description.
+ *
+ * ```ts
+ * import { actorCalled, description, Task } from '@serenity-js/core'
+ *
+ * class PhoneNumber {
+ *   constructor(
+ *     private readonly areaCode: string,
+ *     private readonly centralOfficeCode: string,
+ *     private readonly lineNumber: string,
+ *   ) {}
+ *
+ *   toString() {
+ *     return `(${ this.areaCode }) ${ this.centralOfficeCode }-${ this.lineNumber }`
+ *   }
+ * }
+ *
+ * const dial = (phoneNumber: Answerable<PhoneNumber>) =>
+ *  Task.where(description `#actor dials ${ phoneNumber }`, /* *\/)
+ *
+ * await actorCalled('Alice').attemptsTo(
+ *   dial(new PhoneNumber('555', '123', '4567')),
+ *   // reported as: Alice dials (555) 123-4567
+ * )
+ * ```
+ *
+ * ## Using with objects without a custom `toString` method
+ *
+ * When `the` is parameterised with complex objects that don't have a custom `toString()` method,
+ * or {@link Answerable}s resolving to such objects,
+ * the resulting description will contain a JSON-like string representation of the object.
+ *
+ * ```ts
+ * import { actorCalled, description, Task } from '@serenity-js/core'
+ *
+ * interface PhoneNumber {
+ *   areaCode: string;
+ *   centralOfficeCode: string;
+ *   lineNumber: string;
+ * }
+ *
+ * const dial = (phoneNumber: Answerable<PhoneNumber>) =>
+ *  Task.where(the `#actor dials ${ phoneNumber }`, /* *\/)
+ *
+ * await actorCalled('Alice').attemptsTo(
+ *   dial({ areaCode: '555', centralOfficeCode: '123', lineNumber: '4567' }),
+ *   // reported as: Alice dials { areaCode: "555", centralOfficeCode: "123", lineNumber: "4567" }
+ * )
+ * ```
+ *
+ * ## Using with masked values
+ *
+ * When `the` is parameterised with {@apilink Masked} values,
+ * the resulting description will contain a masked representation of the values.
+ *
+ * ```ts
+ * import { actorCalled, description, Task } from '@serenity-js/core'
+ *
+ * const dial = (phoneNumber: Answerable<string>) =>
+ *  Task.where(description `#actor dials ${ phoneNumber }`, /* *\/)
+ *
+ * await actorCalled('Alice').attemptsTo(
+ *   dial(Masked.valueOf('(555) 123-4567')),
+ *   // reported as: Alice dials [a masked value]
+ * )
+ * ```
+ *
+ * ## Learn more
+ *
+ * - {@apilink Answerable}
+ * - {@apilink Question}
+ * - {@apilink Question.describedAs}
+ * - {@apilink QuestionAdapter}
+ * - {@apilink Masked}
+ *
+ * @group Questions
+ */
+export function the(options: DescriptionFormattingOptions): <Supported_Context_Type>(templates: TemplateStringsArray, ...placeholders: Array<MetaQuestion<Supported_Context_Type, any> | any>) => MetaQuestionAdapter<Supported_Context_Type, string>
+export function the<Supported_Context_Type>(templates: TemplateStringsArray, ...parameters: Array<MetaQuestion<Supported_Context_Type, any> | any>): MetaQuestionAdapter<Supported_Context_Type, string>
+export function the(...args: any[]): any {
+    if (ValueInspector.isPlainObject(args[0])) {
+        const descriptionFormattingOptions = args[0] as DescriptionFormattingOptions;
+
+        return (templates: TemplateStringsArray, ...parameters: Array<any>) =>
+            templateToQuestion(templates, parameters, createParameterToDescriptionMapper(descriptionFormattingOptions), createParameterValueToDescriptionMapper(descriptionFormattingOptions));
+    }
+
+    return templateToQuestion(args[0], args.slice(1), createParameterToDescriptionMapper(), createParameterValueToDescriptionMapper());
+}
+
+/**
+ * A Serenity/JS Screenplay Pattern-flavour
+ * of a [tagged template literal](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#Tagged_templates),
+ * `q` is a tag function capable of resolving any `Answerable<string>` or `Answerable<number>`
+ * you parametrise it with, and returning a `QuestionAdapter<string>`.
+ *
+ * Use `q` to concatenate `string` and `number` values returned from synchronous an asynchronous sources.
+ *
+ * ## Interpolating questions
+ *
+ * ```ts
+ * import { q, actorCalled } from '@serenity-js/core'
+ * import { Send, DeleteRequest } from '@serenity-js/rest'
+ * import { Text } from '@serenity-js/web'
+ *
+ * await actorCalled('Alice').attemptsTo(
+ *   Send.a(DeleteRequest.to(
+ *     q `/articles/${ Text.of(Article.id()) }`
+ *   ))
+ * )
+ * ```
+ *
+ * ## Using a custom description
+ *
+ * ```ts
+ * import { q, actorCalled } from '@serenity-js/core'
+ * import { Send, DeleteRequest } from '@serenity-js/rest'
+ *
+ * await actorCalled('Alice').attemptsTo(
+ *   Send.a(DeleteRequest.to(
+ *     q `/articles/${ Text.of(Article.id()) }`.describedAs('/articles/:id')
+ *   ))
+ * )
+ * ```
+ *
+ * ## Transforming the interpolated string
+ *
+ * The mechanism presented below relies on {@apilink QuestionAdapter}.
+ *
+ * ```ts
+ * import { q, actorCalled } from '@serenity-js/core'
+ * import { Send, DeleteRequest } from '@serenity-js/rest'
+ *
+ * await actorCalled('Alice').attemptsTo(
+ *   Send.a(DeleteRequest.to(
+ *     q `/articles/${ Text.of(Article.id()) }`.toLocaleLowerCase()
+ *   ))
+ * )
+ * ```
+ *
+ * ## Learn more
+ *
+ * - {@apilink Answerable}
+ * - {@apilink Question}
+ * - {@apilink Question.describedAs}
+ * - {@apilink QuestionAdapter}
+ *
+ * @group Questions
+ *
+ * @param templates
+ * @param parameters
+ */
+export function q(templates: TemplateStringsArray, ...parameters: Array<Answerable<string | number>>): QuestionAdapter<string> {
+    return templateToQuestion(
+        templates,
+        parameters,
+        (parameter: Answerable<string | number>) => {
+            // return static string and number parameter values as is
+            if (typeof parameter === 'string' || typeof parameter === 'number') {
+                return String(parameter);
+            }
+            // for Questions, Promises and other Answerables, return their description
+            return `{${ createParameterToDescriptionMapper()(parameter) }}`
+        },
+        createParameterValueMapper()
+    );
+}
+
+function createParameterToDescriptionMapper(options?: DescriptionFormattingOptions) {
+    return (parameter: any) =>
+        parameter === undefined
+            ? 'undefined'
+            : Question.formattedValue(options).of(parameter).toString();
+}
+
+function createParameterValueToDescriptionMapper(options?: DescriptionFormattingOptions) {
+    return async (actor: AnswersQuestions & UsesAbilities & { name: string }, parameter: any) =>
+        parameter instanceof Describable
+            ? parameter.describedBy(actor)
+            : actor.answer(Question.formattedValue(options).of(parameter))
+}
+
+function createParameterValueMapper() {
+    return async (actor: AnswersQuestions & UsesAbilities & { name: string }, parameter: Answerable<string | number>) =>
+        actor.answer(parameter)
+}
+
+function templateToQuestion(
+    templates: TemplateStringsArray,
+    parameters: Array<any>,
+    descriptionMapper: (parameter: any) => string,
+    valueMapper: (actor: AnswersQuestions & UsesAbilities & { name: string }, parameter: any) => Promise<any> | any,
+) {
+    const description = interpolate(templates, parameters.map(parameter => descriptionMapper(parameter)));
+
+    return Question.about<string, any>(description,
+        async (actor: AnswersQuestions & UsesAbilities & { name: string }) => {
+            const descriptions = await asyncMap(parameters, parameter => valueMapper(actor, parameter));
+
+            return interpolate(templates, descriptions);
+        },
+        (context: any) =>
+            templateToQuestion(
+                templates,
+                parameters.map(parameter =>
+                    Question.isAMetaQuestion(parameter)
+                        ? parameter.of(context)
+                        : parameter
+                ),
+                descriptionMapper,
+                valueMapper,
+            )
+    );
+}
+
+function interpolate(templates: TemplateStringsArray, parameters: Array<any>): string {
+    return templates.flatMap((template, i) =>
+        i < parameters.length
+            ? [ template, parameters[i] ]
+            : [ template ],
+    ).join('');
+}

package/src/screenplay/time/activities/Wait.ts

@@ -5,7 +5,8 @@ import { d } from '../../../io';
 import type { UsesAbilities } from '../../abilities';
 import type { Answerable } from '../../Answerable';
 import { Interaction } from '../../Interaction';
-import type { AnswersQuestions, Expectation, ExpectationOutcome } from '../../questions';
+import type { AnswersQuestions, Expectation, ExpectationOutcome} from '../../questions';
+import { the } from '../../questions';
 import { ExpectationMet } from '../../questions';
 import { ScheduleWork } from '../abilities';
 import { Duration } from '../models';
@@ -202,7 +203,7 @@ export class Wait {
  */
 class WaitFor extends Interaction {
     constructor(private readonly duration: Answerable<Duration>) {
-        super(d`#actor waits for ${ duration }`);
+        super(the`#actor waits for ${ duration }`);
     }
 
     async performAs(actor: UsesAbilities & AnswersQuestions): Promise<void> {
@@ -231,7 +232,7 @@ export class WaitUntil<Actual> extends Interaction {
         private readonly pollingInterval: Duration,
         private readonly timeout?: Duration,
     ) {
-        super(d`#actor waits until ${ actual } does ${ expectation }`);
+        super(the`#actor waits until ${ actual } does ${ expectation }`);
 
         if (timeout) {
             ensure('Timeout', timeout.inMilliseconds(), isGreaterThanOrEqualTo(Wait.minimumTimeout.inMilliseconds()));

package/lib/io/isPlainObject.d.ts

@@ -1,7 +0,0 @@
-/**
- * Checks if the value has a good chance of being a plain JavaScript object
- *
- * @param v
- */
-export declare function isPlainObject(v: unknown): v is object;
-//# sourceMappingURL=isPlainObject.d.ts.map

package/lib/io/isPlainObject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isPlainObject.d.ts","sourceRoot":"","sources":["../../src/io/isPlainObject.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,MAAM,CAkBrD"}

package/lib/io/isPlainObject.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPlainObject = void 0;
-/**
- * Checks if the value has a good chance of being a plain JavaScript object
- *
- * @param v
- */
-function isPlainObject(v) {
-    // Basic check for Type object that's not null
-    if (typeof v === 'object' && v !== null) {
-        // If Object.getPrototypeOf supported, use it
-        if (typeof Object.getPrototypeOf === 'function') {
-            const proto = Object.getPrototypeOf(v);
-            return proto === Object.prototype || proto === null;
-        }
-        // Otherwise, use internal class
-        // This should be reliable as if getPrototypeOf not supported, is pre-ES5
-        return Object.prototype.toString.call(v) === '[object Object]';
-    }
-    // Not an object
-    return false;
-}
-exports.isPlainObject = isPlainObject;
-//# sourceMappingURL=isPlainObject.js.map

package/lib/io/isPlainObject.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isPlainObject.js","sourceRoot":"","sources":["../../src/io/isPlainObject.ts"],"names":[],"mappings":";;;AAAA;;;;GAIG;AACH,SAAgB,aAAa,CAAC,CAAU;IAEpC,8CAA8C;IAC9C,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI,EAAE;QAErC,6CAA6C;QAC7C,IAAI,OAAO,MAAM,CAAC,cAAc,KAAK,UAAU,EAAE;YAC7C,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;YACvC,OAAO,KAAK,KAAK,MAAM,CAAC,SAAS,IAAI,KAAK,KAAK,IAAI,CAAC;SACvD;QAED,gCAAgC;QAChC,yEAAyE;QACzE,OAAO,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,iBAAiB,CAAC;KAClE;IAED,gBAAgB;IAChB,OAAO,KAAK,CAAC;AACjB,CAAC;AAlBD,sCAkBC"}

package/lib/io/reflection/isPrimitive.d.ts

@@ -1,8 +0,0 @@
-/**
- * Returns true if `value` is a [JavaScript primitive](https://developer.mozilla.org/en-US/docs/Glossary/Primitive),
- * false otherwise.
- *
- * @param value
- */
-export declare function isPrimitive(value: unknown): boolean;
-//# sourceMappingURL=isPrimitive.d.ts.map

package/lib/io/reflection/isPrimitive.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isPrimitive.d.ts","sourceRoot":"","sources":["../../../src/io/reflection/isPrimitive.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAanD"}

package/lib/io/reflection/isPrimitive.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPrimitive = void 0;
-/**
- * Returns true if `value` is a [JavaScript primitive](https://developer.mozilla.org/en-US/docs/Glossary/Primitive),
- * false otherwise.
- *
- * @param value
- */
-function isPrimitive(value) {
-    if (value === null) {
-        return true;
-    }
-    return [
-        'string',
-        'number',
-        'bigint',
-        'boolean',
-        'undefined',
-        'symbol'
-    ].includes(typeof value);
-}
-exports.isPrimitive = isPrimitive;
-//# sourceMappingURL=isPrimitive.js.map

package/lib/io/reflection/isPrimitive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isPrimitive.js","sourceRoot":"","sources":["../../../src/io/reflection/isPrimitive.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACH,SAAgB,WAAW,CAAC,KAAc;IACtC,IAAI,KAAK,KAAK,IAAI,EAAE;QAChB,OAAO,IAAI,CAAC;KACf;IAED,OAAO;QACH,QAAQ;QACR,QAAQ;QACR,QAAQ;QACR,SAAS;QACT,WAAW;QACX,QAAQ;KACX,CAAC,QAAQ,CAAC,OAAO,KAAK,CAAC,CAAC;AAC7B,CAAC;AAbD,kCAaC"}

package/lib/io/reflection/typeOf.d.ts

@@ -1,7 +0,0 @@
-/**
- * Describes the type of the provided value.
- *
- * @param value
- */
-export declare function typeOf(value: unknown): string;
-//# sourceMappingURL=typeOf.d.ts.map

package/lib/io/reflection/typeOf.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"typeOf.d.ts","sourceRoot":"","sources":["../../../src/io/reflection/typeOf.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAuB7C"}

package/lib/io/reflection/typeOf.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeOf = void 0;
-const util_1 = require("util");
-/**
- * Describes the type of the provided value.
- *
- * @param value
- */
-function typeOf(value) {
-    switch (true) {
-        case value === null:
-            return 'null';
-        case util_1.types.isProxy(value):
-            return `Proxy<${Reflect.getPrototypeOf(value).constructor.name}>`;
-        case typeof value !== 'object':
-            return typeof value;
-        case value instanceof Date:
-            return `Date`;
-        case Array.isArray(value):
-            return `Array`;
-        case value instanceof RegExp:
-            return `RegExp`;
-        case value instanceof Set:
-            return 'Set';
-        case value instanceof Map:
-            return 'Map';
-        case !!value.constructor && value.constructor !== Object:
-            return value.constructor.name;
-        default:
-            return 'object';
-    }
-}
-exports.typeOf = typeOf;
-//# sourceMappingURL=typeOf.js.map

package/lib/io/reflection/typeOf.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"typeOf.js","sourceRoot":"","sources":["../../../src/io/reflection/typeOf.ts"],"names":[],"mappings":";;;AAAA,+BAA6B;AAE7B;;;;GAIG;AACH,SAAgB,MAAM,CAAC,KAAc;IACjC,QAAQ,IAAI,EAAE;QACV,KAAK,KAAK,KAAK,IAAI;YACf,OAAO,MAAM,CAAC;QAClB,KAAK,YAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YACrB,OAAO,SAAU,OAAO,CAAC,cAAc,CAAC,KAAe,CAAC,CAAC,WAAW,CAAC,IAAK,GAAG,CAAC;QAClF,KAAK,OAAO,KAAK,KAAK,QAAQ;YAC1B,OAAO,OAAO,KAAK,CAAC;QACxB,KAAK,KAAK,YAAY,IAAI;YACtB,OAAO,MAAM,CAAC;QAClB,KAAK,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YACrB,OAAO,OAAO,CAAC;QACnB,KAAK,KAAK,YAAY,MAAM;YACxB,OAAO,QAAQ,CAAA;QACnB,KAAK,KAAK,YAAY,GAAG;YACrB,OAAO,KAAK,CAAC;QACjB,KAAK,KAAK,YAAY,GAAG;YACrB,OAAO,KAAK,CAAC;QACjB,KAAK,CAAC,CAAE,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,WAAW,KAAK,MAAM;YACrD,OAAO,KAAK,CAAC,WAAW,CAAC,IAAI,CAAA;QACjC;YACI,OAAO,QAAQ,CAAC;KACvB;AACL,CAAC;AAvBD,wBAuBC"}