@tstdl/base 0.83.20 → 0.83.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.83.20",
+  "version": "0.83.21",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -62,7 +62,7 @@
     "preact-render-to-string": "^5.2",
     "puppeteer": "^19.8",
     "undici": "^5.21",
-    "urlpattern-polyfill": "^6.0"
+    "urlpattern-polyfill": "^7.0"
   },
   "peerDependenciesMeta": {
     "@tstdl/angular": {

package/schema/decorators/types.d.ts

@@ -1,7 +1,7 @@
 import type { OneOrMany } from '../../types.js';
 import type { SchemaTestable } from '../schema.js';
 import type { ObjectSchema, SchemaArrayConstraint, SchemaFactoryFunction, SchemaValueCoercer, SchemaValueConstraint, SchemaValueTransformer, TypeSchema, ValueSchema, ValueType } from '../types/index.js';
-export type SchemaTypeReflectionData = Partial<Pick<ObjectSchema, 'mask' | 'allowUnknownProperties'>> & {
+export type SchemaTypeReflectionData = Partial<Pick<ObjectSchema, 'mask' | 'unknownProperties' | 'unknownPropertiesKey'>> & {
     schema?: ObjectSchema | TypeSchema | ValueType;
     factory?: SchemaFactoryFunction<any>;
 };

package/schema/schema.js

@@ -147,7 +147,7 @@ function testObject(objectSchema, value, options = {}, path = import_json_path.J
   const schemaPropertyKeys = (0, import_object.objectKeys)(schema.properties);
   const valuePropertyKeys = (0, import_object.objectKeys)(value);
   const unknownValuePropertyKeys = (0, import_set.differenceSets)(new Set(valuePropertyKeys), new Set(schemaPropertyKeys));
-  if (unknownValuePropertyKeys.length > 0 && !(mask || schema.allowUnknownProperties.size > 0)) {
+  if (unknownValuePropertyKeys.length > 0 && !mask && !schema.allowUnknownProperties) {
     return { valid: false, error: new import_schema_error.SchemaError("Unknown property", { path: path.add(unknownValuePropertyKeys[0]), fast: options.fastErrors }) };
   }
   for (const key of schemaPropertyKeys) {
@@ -157,9 +157,16 @@ function testObject(objectSchema, value, options = {}, path = import_json_path.J
     }
     resultValue[key] = propertyResult.value;
   }
-  if (schema.allowUnknownProperties.size > 0) {
+  if (schema.allowUnknownProperties) {
     for (const key of unknownValuePropertyKeys) {
-      const propertyResult = testWithFastError((0, import_types.valueSchema)([...schema.allowUnknownProperties]), value[key], options, path.add(key));
+      const propertyPath = path.add(key);
+      if ((0, import_type_guards.isDefined)(schema.unknownPropertiesKey)) {
+        const keyResult = testWithFastError(schema.unknownPropertiesKey, key, options);
+        if (!keyResult.valid && !mask) {
+          return { valid: false, error: new import_schema_error.SchemaError("Invalid property key.", { path: propertyPath, inner: keyResult.error, fast: options.fastErrors }) };
+        }
+      }
+      const propertyResult = testWithFastError(schema.unknownProperties, value[key], options, path.add(key));
       if (!propertyResult.valid && !mask) {
         return propertyResult;
       }

package/schema/schemas/assign.js

@@ -23,6 +23,7 @@ __export(assign_exports, {
 module.exports = __toCommonJS(assign_exports);
 var import_array = require("../../utils/array/array.js");
 var import_type_guards = require("../../utils/type-guards.js");
+var import_types = require("../types/index.js");
 var import_utils = require("../utils/index.js");
 function assign(...inputs) {
   const schemas = inputs.map(import_utils.getObjectSchema);
@@ -36,14 +37,11 @@ function assign(...inputs) {
         ...result.properties,
         ...schemas[i].properties
       },
-      allowUnknownProperties: [...(0, import_array.toArray)(result.allowUnknownProperties ?? []), ...(0, import_array.toArray)(schemas[i].allowUnknownProperties ?? [])]
+      unknownProperties: [...(0, import_array.toArray)(result.unknownProperties ?? []), ...(0, import_array.toArray)(schemas[i].unknownProperties ?? [])],
+      unknownPropertiesKey: [...(0, import_array.toArray)(result.unknownPropertiesKey ?? []), ...(0, import_array.toArray)(schemas[i].unknownPropertiesKey ?? [])]
     };
   }
-  if (result.allowUnknownProperties.length == 0) {
-    const { allowUnknownProperties: _, ...rest } = result;
-    result = rest;
-  }
   result.sourceType = void 0;
   result.factory = void 0;
-  return result;
+  return (0, import_types.optimizeObjectSchema)(result);
 }

package/schema/schemas/object.d.ts

@@ -1,6 +1,7 @@
-import type { Record, SimplifiedOptionalize, TypedOmit } from '../../types.js';
-import type { ObjectSchema, ObjectSchemaProperties } from '../types/index.js';
-export type ObjectOptions<T extends Record = Record> = TypedOmit<ObjectSchema<T>, 'properties'>;
+import type { Record, SimplifiedOptionalize, SimplifyObject, TypedOmit } from '../../types.js';
+import type { IfNever } from 'type-fest';
+import type { ObjectSchema, ObjectSchemaProperties, TypedObjectSchemaUnknownProperties } from '../types/index.js';
+export type ObjectOptions<T extends Record = Record> = TypedOmit<ObjectSchema<T>, 'properties' | 'unknownProperties' | 'unknownPropertiesKey'>;
 export declare function explicitObject<T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T>): ObjectSchema<T>;
-export declare function object<T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T>): ObjectSchema<SimplifiedOptionalize<T>>;
+export declare function object<T extends Record = Record<never>, K extends PropertyKey = any, V = never>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T> & TypedObjectSchemaUnknownProperties<K, V>): ObjectSchema<SimplifyObject<SimplifiedOptionalize<T> & IfNever<V, {}, Record<K, V>>>>;
 export declare const emptyObjectSchema: ObjectSchema<{}>;

package/schema/schemas/record.d.ts

@@ -1,5 +1,5 @@
 import type { OneOrMany, Record, TypedOmit } from '../../types.js';
 import type { SchemaTestable } from '../schema.js';
 import type { ObjectSchema } from '../types/index.js';
-export type RecordOptions<T extends Record = Record> = TypedOmit<ObjectSchema<T>, 'properties' | 'allowUnknownProperties' | 'mask'>;
-export declare function record<T>(valueType: OneOrMany<SchemaTestable<T>>, options?: RecordOptions): ObjectSchema<Record<any, T>>;
+export type RecordOptions<T extends Record = Record> = TypedOmit<ObjectSchema<T>, 'properties' | 'unknownProperties' | 'unknownPropertiesKey' | 'mask'>;
+export declare function record<K extends PropertyKey, T>(keySchema: OneOrMany<SchemaTestable<K>>, valueSchema: OneOrMany<SchemaTestable<T>>, options?: RecordOptions): ObjectSchema<Record<K, T>>;

package/schema/schemas/record.js

@@ -22,10 +22,11 @@ __export(record_exports, {
 });
 module.exports = __toCommonJS(record_exports);
 var import_types = require("../types/index.js");
-function record(valueType, options) {
+function record(keySchema, valueSchema, options) {
   return (0, import_types.objectSchema)({
     properties: {},
-    allowUnknownProperties: valueType,
+    unknownProperties: valueSchema,
+    unknownPropertiesKey: keySchema,
     ...options
   });
 }

package/schema/types/types.d.ts

@@ -1,11 +1,12 @@
 import type { AbstractConstructor, OneOrMany, Record, Type, TypedOmit } from '../../types.js';
-import type { NormalizedSchema, Schema, SchemaTestable } from '../schema.js';
 import type { SchemaError } from '../schema.error.js';
+import type { NormalizedSchema, Schema, SchemaTestable } from '../schema.js';
 import type { SchemaArrayConstraint } from './schema-array-constraint.js';
 import type { SchemaValueCoercer } from './schema-value-coercer.js';
 import type { SchemaValueConstraint } from './schema-value-constraint.js';
 import type { SchemaValueTransformer } from './schema-value-transformer.js';
 declare const schemaOutputTypeSymbol: unique symbol;
+declare const optimized: unique symbol;
 export type SchemaFactoryFunction<T> = (data: T) => T;
 export type SchemaFactory<T> = {
     type: Type<T>;
@@ -26,12 +27,18 @@ export type TupleSchemaOutput<T extends readonly SchemaTestable[]> = {
 };
 export type ObjectSchemaOrType<T = any> = ObjectSchema<T> | AbstractConstructor<T>;
 export type ObjectSchema<T = any> = {
+    [optimized]?: boolean;
     [schemaOutputTypeSymbol]?: T;
     sourceType?: ValueType;
     factory?: SchemaFactory<T>;
     properties: ObjectSchemaProperties<T>;
     mask?: boolean;
-    allowUnknownProperties?: OneOrMany<SchemaTestable>;
+    unknownProperties?: OneOrMany<SchemaTestable>;
+    unknownPropertiesKey?: OneOrMany<SchemaTestable>;
+};
+export type TypedObjectSchemaUnknownProperties<K extends PropertyKey, V> = {
+    unknownProperties?: OneOrMany<SchemaTestable<V>>;
+    unknownPropertiesKey?: OneOrMany<SchemaTestable<K>>;
 };
 export type TypeSchema<T = any> = {
     type: ValueType<T>;
@@ -40,6 +47,7 @@ export type NormalizedTypeSchema<T = any> = {
     foo: ResolvedValueType<T>;
 };
 export type ValueSchema<T = unknown> = {
+    [optimized]?: boolean;
     [schemaOutputTypeSymbol]?: T;
     schema: OneOrMany<SchemaTestable<T>>;
     array?: boolean;
@@ -59,11 +67,13 @@ export type NormalizedObjectSchema<T = any> = {
     factory?: SchemaFactory<T>;
     properties: NormalizedObjectSchemaProperties<T>;
     mask?: boolean;
-    allowUnknownProperties: Set<Schema>;
+    allowUnknownProperties: boolean;
+    unknownProperties?: Schema;
+    unknownPropertiesKey?: Schema;
 };
 export type NormalizedValueSchema<T = any> = {
     [schemaOutputTypeSymbol]?: T;
-    schema: Set<Schema<T>>;
+    schema: Schema<T>[];
     array: boolean;
     optional: boolean;
     nullable: boolean;
@@ -156,7 +166,7 @@ export declare function isDeferredValueType<T>(value: SchemaTestable<T>): value
 export declare function isDeferredValueType(value: any): value is DeferredValueType;
 export declare function resolveValueTypes<T>(valueTypes: OneOrMany<ValueType<T>>): OneOrMany<ResolvedValueType<T>>;
 export declare function resolveValueType<T>(valueType: ValueType<T>): ResolvedValueType<T>;
-export declare function valueTypesOrSchemasToSchemas<T>(valueTypesOrSchemas: OneOrMany<SchemaTestable<T>>): OneOrMany<Schema<T>>;
+export declare function schemaTestablesToSchemas<T>(schemaTestables: OneOrMany<SchemaTestable<T>>): OneOrMany<Schema<T>>;
 export declare function schemaTestableToSchema<T>(valueTypeOrSchema: SchemaTestable<T>): Schema<T>;
 export declare function optimizeObjectSchema<T>(schema: ObjectSchema<T>): ObjectSchema<T>;
 export declare function optimizeObjectSchemaProperties<T>(properties: ObjectSchemaProperties<T>): ObjectSchemaProperties<T>;

package/schema/types/types.js

@@ -35,15 +35,17 @@ __export(types_exports, {
   resolveValueType: () => resolveValueType,
   resolveValueTypes: () => resolveValueTypes,
   schemaTestableToSchema: () => schemaTestableToSchema,
+  schemaTestablesToSchemas: () => schemaTestablesToSchemas,
   transformErrorResult: () => transformErrorResult,
   transformErrorResultSymbol: () => transformErrorResultSymbol,
   typeSchema: () => typeSchema,
-  valueSchema: () => valueSchema,
-  valueTypesOrSchemasToSchemas: () => valueTypesOrSchemasToSchemas
+  valueSchema: () => valueSchema
 });
 module.exports = __toCommonJS(types_exports);
+var import_array = require("../../utils/array/array.js");
 var import_object = require("../../utils/object/object.js");
 var import_type_guards = require("../../utils/type-guards.js");
+const optimized = Symbol("schema optimized");
 const primitiveConstructors = [String, Number, Boolean, Symbol, BigInt, Function, "undefined", "null"];
 const primitiveConstructorSet = new Set(primitiveConstructors);
 const transformErrorResultSymbol = Symbol("Transform error");
@@ -60,6 +62,7 @@ function objectSchema(schema) {
   return optimizeObjectSchema(schema);
 }
 function valueSchema(schema, options) {
+  (0, import_type_guards.assert)(!(0, import_type_guards.isArray)(schema) || schema.length > 0, "No schema provided.");
   return optimizeValueSchema({ schema, ...options });
 }
 function typeSchema(type) {
@@ -93,11 +96,17 @@ function resolveValueTypes(valueTypes) {
 function resolveValueType(valueType) {
   return isDeferredValueType(valueType) ? resolveValueType(valueType.deferred()) : valueType;
 }
-function valueTypesOrSchemasToSchemas(valueTypesOrSchemas) {
-  if ((0, import_type_guards.isArray)(valueTypesOrSchemas)) {
-    return valueTypesOrSchemas.map(schemaTestableToSchema);
+function schemaTestablesToSchemas(schemaTestables) {
+  if ((0, import_type_guards.isArray)(schemaTestables)) {
+    if (schemaTestables.length == 1) {
+      return schemaTestableToSchema(schemaTestables[0]);
+    }
+    if (schemaTestables.length == 0) {
+      throw new Error("No schema provided.");
+    }
+    return schemaTestables.map(schemaTestableToSchema);
   }
-  return schemaTestableToSchema(valueTypesOrSchemas);
+  return schemaTestableToSchema(schemaTestables);
 }
 function schemaTestableToSchema(valueTypeOrSchema) {
   if (isSchema(valueTypeOrSchema)) {
@@ -106,25 +115,38 @@ function schemaTestableToSchema(valueTypeOrSchema) {
   return typeSchema(valueTypeOrSchema);
 }
 function optimizeObjectSchema(schema) {
-  return {
-    ...(0, import_object.filterObject)(schema, import_type_guards.isDefined),
-    properties: optimizeObjectSchemaProperties(schema.properties)
-  };
+  if (schema[optimized] == true) {
+    return schema;
+  }
+  return (0, import_object.filterObject)({
+    [optimized]: true,
+    ...schema,
+    properties: optimizeObjectSchemaProperties(schema.properties),
+    unknownProperties: (0, import_type_guards.isDefined)(schema.unknownProperties) ? optimizeSchema(schema.unknownProperties) : void 0,
+    unknownPropertiesKey: (0, import_type_guards.isDefined)(schema.unknownPropertiesKey) ? optimizeSchema(schema.unknownPropertiesKey) : void 0
+  }, import_type_guards.isDefined);
 }
 function optimizeObjectSchemaProperties(properties) {
-  const entries = (0, import_object.objectEntries)(properties).map(([property, innerSchema]) => [property, optimizeSchema(innerSchema)]);
-  return Object.fromEntries(entries);
+  return (0, import_object.mapObjectValues)(properties, optimizeSchema);
 }
 function optimizeValueSchema(schema) {
-  const optimized = optimizeSchema(schema);
-  return isValueSchema(optimized) ? optimized : { schema: optimized };
+  const optimizedSchema = optimizeSchema(schema);
+  return isValueSchema(optimizedSchema) ? optimizedSchema : { [optimized]: true, schema: optimizedSchema };
 }
 function optimizeSchema(schema) {
   if ((0, import_type_guards.isArray)(schema)) {
+    if (schema[optimized] == true) {
+      return schema;
+    }
     if (schema.length == 1) {
       return optimizeSchema(schema[0]);
     }
-    return schema.flatMap(optimizeSchema);
+    if (schema.length == 0) {
+      throw new Error("No schema provided.");
+    }
+    const optimizedSchemas = (0, import_array.distinct)((0, import_array.distinct)(schema).flatMap(optimizeSchema));
+    optimizedSchemas[optimized] = true;
+    return optimizedSchemas;
   }
   if ((0, import_type_guards.isFunction)(schema) || (0, import_type_guards.isString)(schema) || isDeferredValueType(schema)) {
     return schema;
@@ -133,19 +155,18 @@ function optimizeSchema(schema) {
     return schema.type;
   }
   if (isValueSchema(schema)) {
+    if (schema[optimized] == true) {
+      return schema;
+    }
     const entries = (0, import_object.objectEntries)(schema).filter(([, value]) => (0, import_type_guards.isDefined)(value));
     if (entries.length == 1) {
-      if (!(0, import_type_guards.isArray)(schema.schema)) {
-        return optimizeSchema(schema.schema);
-      } else if (schema.schema.length == 1) {
-        return optimizeSchema(schema.schema[0]);
-      }
-      return schema.schema.map(optimizeSchema);
+      return optimizeSchema(schema.schema);
     }
     if (isValueSchema(schema.schema)) {
       const combinedProperties = /* @__PURE__ */ new Set([...(0, import_object.objectKeys)(schema), ...(0, import_object.objectKeys)(schema.schema)]);
       if (isValueSchema(schema.schema) && !combinedProperties.has("array") && !combinedProperties.has("coerce") && !combinedProperties.has("coercers") && !combinedProperties.has("transformers") && !combinedProperties.has("arrayConstraints") && !combinedProperties.has("valueConstraints")) {
         return {
+          [optimized]: true,
           schema: optimizeSchema(schema.schema.schema),
           ...(0, import_object.filterObject)({
             optional: (schema.optional ?? false) || (schema.schema.optional ?? false) ? true : void 0,
@@ -156,6 +177,7 @@ function optimizeSchema(schema) {
     }
     const { schema: innerSchema, optional, nullable, coercers, transformers, arrayConstraints, valueConstraints, ...rest } = schema;
     return (0, import_object.filterObject)({
+      [optimized]: true,
       schema: optimizeSchema(innerSchema),
       optional: optional ?? false ? true : void 0,
       nullable: nullable ?? false ? true : void 0,

package/schema/utils/schema.js

@@ -57,17 +57,22 @@ function _normalizeSchema(schema) {
   throw new Error("Unsupported schema.");
 }
 function _normalizeObjectSchema(schema) {
+  const unknownPropertiesSchema = (0, import_type_guards.isDefined)(schema.unknownProperties) ? (0, import_types.schemaTestablesToSchemas)(schema.unknownProperties) : void 0;
+  const unknownPropertiesKeySchema = (0, import_type_guards.isDefined)(schema.unknownPropertiesKey) ? (0, import_types.schemaTestablesToSchemas)(schema.unknownPropertiesKey) : void 0;
+  const allowUnknownProperties = (0, import_type_guards.isArray)(unknownPropertiesSchema) && unknownPropertiesSchema.length > 0 || (0, import_type_guards.isDefined)(unknownPropertiesSchema);
   const normalizedSchema = {
     factory: schema.factory,
-    properties: (0, import_object.mapObjectValues)(schema.properties, (propertyValueType) => (0, import_types.valueTypesOrSchemasToSchemas)(propertyValueType)),
+    properties: (0, import_object.mapObjectValues)(schema.properties, (propertyValueType) => (0, import_types.schemaTestablesToSchemas)(propertyValueType)),
     mask: schema.mask,
-    allowUnknownProperties: new Set((0, import_array.toArray)(schema.allowUnknownProperties ?? []).map(import_types.schemaTestableToSchema))
+    allowUnknownProperties,
+    unknownProperties: (0, import_type_guards.isArray)(unknownPropertiesSchema) ? (0, import_types.valueSchema)(unknownPropertiesSchema) : unknownPropertiesSchema,
+    unknownPropertiesKey: (0, import_type_guards.isArray)(unknownPropertiesKeySchema) ? (0, import_types.valueSchema)(unknownPropertiesKeySchema) : unknownPropertiesKeySchema
   };
   return normalizedSchema;
 }
 function _normalizeValueSchema(schema) {
   const normalizedValueSchema = {
-    schema: new Set((0, import_array.toArray)(schema.schema).map(import_types.schemaTestableToSchema)),
+    schema: [...new Set((0, import_array.toArray)(schema.schema))].map(import_types.schemaTestableToSchema),
     array: schema.array ?? false,
     optional: schema.optional ?? false,
     nullable: schema.nullable ?? false,
@@ -120,7 +125,8 @@ function _tryGetObjectSchemaFromReflection(type) {
     factory: (0, import_type_guards.isDefined)(typeData.factory) ? { builder: typeData.factory } : { type },
     properties: dataSchema?.properties ?? getObjectSchemaPropertiesFromReflection(metadata, type),
     mask: typeData.mask ?? dataSchema?.mask,
-    allowUnknownProperties: ((0, import_type_guards.isUndefined)(typeData.allowUnknownProperties) || (0, import_type_guards.isArray)(typeData.allowUnknownProperties) && typeData.allowUnknownProperties.length == 0 ? void 0 : typeData.allowUnknownProperties) ?? dataSchema?.allowUnknownProperties
+    unknownProperties: ((0, import_type_guards.isUndefined)(typeData.unknownProperties) || (0, import_type_guards.isArray)(typeData.unknownProperties) && typeData.unknownProperties.length == 0 ? void 0 : typeData.unknownProperties) ?? dataSchema?.unknownProperties,
+    unknownPropertiesKey: ((0, import_type_guards.isUndefined)(typeData.unknownPropertiesKey) || (0, import_type_guards.isArray)(typeData.unknownPropertiesKey) && typeData.unknownPropertiesKey.length == 0 ? void 0 : typeData.unknownPropertiesKey) ?? dataSchema?.unknownPropertiesKey
   });
   if ((0, import_type_guards.isUndefined)(dataSchema)) {
     const prototype = Reflect.getPrototypeOf(type);
@@ -140,7 +146,7 @@ function getObjectSchemaPropertiesFromReflection(metadata, type) {
     if (array && ((0, import_type_guards.isUndefined)(itemType) || (0, import_type_guards.isArray)(itemType) && itemType.length == 0)) {
       throw new Error(`Item type missing on type ${type.name} at property "${String(key)}"`);
     }
-    properties[key] = (0, import_types.valueSchema)((0, import_types.valueTypesOrSchemasToSchemas)(itemType ?? propertyMetadata.type), {
+    properties[key] = (0, import_types.valueSchema)((0, import_types.schemaTestablesToSchemas)(itemType ?? propertyMetadata.type), {
       array,
       optional: reflectionData?.optional,
       nullable: reflectionData?.nullable,

package/templates/template.model.js

@@ -59,7 +59,7 @@ __decorate([
   __metadata("design:type", Object)
 ], TemplateField.prototype, "options", void 0);
 TemplateField = __decorate([
-  (0, import_schema.Class)({ allowUnknownProperties: (0, import_schema.any)() })
+  (0, import_schema.Class)({ unknownProperties: (0, import_schema.any)() })
 ], TemplateField);
 class Template {
   /** name of template */
@@ -72,7 +72,7 @@ __decorate([
   __metadata("design:type", String)
 ], Template.prototype, "name", void 0);
 __decorate([
-  (0, import_schema.Property)({ schema: (0, import_schema.object)({}, { allowUnknownProperties: TemplateField }) }),
+  (0, import_schema.Property)({ schema: (0, import_schema.object)({}, { unknownProperties: TemplateField }) }),
   __metadata("design:type", Object)
 ], Template.prototype, "fields", void 0);
 __decorate([

package/utils/array/array.d.ts

@@ -1,3 +1,4 @@
+import type { IteratorFunction } from '../iterable-helpers/types.js';
 /**
  * Returns value as is, if it is an array, otherwise puts the single value into an array.
  */
@@ -12,6 +13,7 @@ export declare function toArrayCopy<T>(value: T | T[] | readonly T[]): T[];
  */
 export declare function extractValueOfArrayIfSingleElement<T>(value: T | T[]): T | T[];
 export declare function extractValueOfArrayIfSingleElement<T>(value: T | readonly T[]): T | readonly T[];
+export declare function distinct<T>(values: Iterable<T>, selector?: IteratorFunction<T, any>): T[];
 /**
  * creates a new array of specified length and fills it with values from the specified value provider function
  * @param length length of the new array

package/utils/array/array.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var array_exports = {};
 __export(array_exports, {
   createArray: () => createArray,
+  distinct: () => distinct,
   extractValueOfArrayIfSingleElement: () => extractValueOfArrayIfSingleElement,
   randomItem: () => randomItem,
   randomItems: () => randomItems,
@@ -27,6 +28,7 @@ __export(array_exports, {
   toArrayCopy: () => toArrayCopy
 });
 module.exports = __toCommonJS(array_exports);
+var import_distinct = require("../iterable-helpers/distinct.js");
 var import_math = require("../math.js");
 var import_type_guards = require("../type-guards.js");
 function toArray(value) {
@@ -41,6 +43,9 @@ function extractValueOfArrayIfSingleElement(value) {
   }
   return value;
 }
+function distinct(values, selector) {
+  return [...(0, import_type_guards.isDefined)(selector) ? (0, import_distinct.distinct)(values, selector) : new Set(values)];
+}
 function createArray(length, valueProvider) {
   const arr = [];
   arr.length = length;