@tstdl/base 0.87.13 → 0.88.0-alpha1

package/schema/utils/schema.js

@@ -1,161 +1,139 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var schema_exports = {};
-__export(schema_exports, {
-  getArrayItemSchema: () => getArrayItemSchema,
-  getObjectSchema: () => getObjectSchema,
-  getObjectSchemaFromReflection: () => getObjectSchemaFromReflection,
-  normalizeObjectSchema: () => normalizeObjectSchema,
-  normalizeSchema: () => normalizeSchema,
-  normalizeTypeSchema: () => normalizeTypeSchema,
-  normalizeValueSchema: () => normalizeValueSchema,
-  tryGetObjectSchemaFromReflection: () => tryGetObjectSchemaFromReflection
-});
-module.exports = __toCommonJS(schema_exports);
-var import_registry = require("../../reflection/registry.js");
-var import_array = require("../../utils/array/array.js");
-var import_memoize = require("../../utils/function/memoize.js");
-var import_object = require("../../utils/object/object.js");
-var import_type_guards = require("../../utils/type-guards.js");
-var import_assign = require("../schemas/assign.js");
-var import_types = require("../types/index.js");
-const normalizeSchema = (0, import_memoize.memoizeSingle)(_normalizeSchema, { weak: true });
-const normalizeObjectSchema = (0, import_memoize.memoizeSingle)(_normalizeObjectSchema, { weak: true });
-const normalizeValueSchema = (0, import_memoize.memoizeSingle)(_normalizeValueSchema, { weak: true });
-const normalizeTypeSchema = (0, import_memoize.memoizeSingle)(_normalizeTypeSchema, { weak: true });
-const getArrayItemSchema = (0, import_memoize.memoizeSingle)(_getArrayItemSchema, { weak: true });
-const tryGetObjectSchemaFromReflection = (0, import_memoize.memoizeSingle)(_tryGetObjectSchemaFromReflection, { weak: true });
-function getObjectSchema(schemaOrType) {
-  return (0, import_type_guards.isFunction)(schemaOrType) ? getObjectSchemaFromReflection(schemaOrType) : schemaOrType;
+import { reflectionRegistry } from '../../reflection/registry.js';
+import { toArray } from '../../utils/array/array.js';
+import { memoizeSingle } from '../../utils/function/memoize.js';
+import { mapObjectValues } from '../../utils/object/object.js';
+import { isArray, isDefined, isFunction, isNotNull, isNull, isUndefined } from '../../utils/type-guards.js';
+import { assign } from '../schemas/assign.js';
+import { isObjectSchema, isTypeSchema, isValueSchema, objectSchema, resolveValueType, schemaTestableToSchema, schemaTestablesToSchemas, valueSchema } from '../types/index.js';
+export const normalizeSchema = memoizeSingle(_normalizeSchema, { weak: true });
+export const normalizeObjectSchema = memoizeSingle(_normalizeObjectSchema, { weak: true });
+export const normalizeValueSchema = memoizeSingle(_normalizeValueSchema, { weak: true });
+export const normalizeTypeSchema = memoizeSingle(_normalizeTypeSchema, { weak: true });
+export const getArrayItemSchema = memoizeSingle(_getArrayItemSchema, { weak: true });
+export const tryGetObjectSchemaFromReflection = memoizeSingle(_tryGetObjectSchemaFromReflection, { weak: true });
+export function getObjectSchema(schemaOrType) {
+    return isFunction(schemaOrType)
+        ? getObjectSchemaFromReflection(schemaOrType)
+        : schemaOrType;
 }
 function _normalizeSchema(schema) {
-  if ((0, import_types.isObjectSchema)(schema)) {
-    return normalizeObjectSchema(schema);
-  }
-  if ((0, import_types.isValueSchema)(schema)) {
-    return normalizeValueSchema(schema);
-  }
-  if ((0, import_types.isTypeSchema)(schema)) {
-    return normalizeTypeSchema(schema);
-  }
-  throw new Error("Unsupported schema.");
+    if (isObjectSchema(schema)) {
+        return normalizeObjectSchema(schema);
+    }
+    if (isValueSchema(schema)) {
+        return normalizeValueSchema(schema);
+    }
+    if (isTypeSchema(schema)) {
+        return normalizeTypeSchema(schema);
+    }
+    throw new Error('Unsupported schema.');
 }
 function _normalizeObjectSchema(schema) {
-  const unknownPropertiesSchema = (0, import_type_guards.isDefined)(schema.unknownProperties) && (!(0, import_type_guards.isArray)(schema.unknownProperties) || schema.unknownProperties.length > 0) ? (0, import_types.schemaTestablesToSchemas)(schema.unknownProperties) : void 0;
-  const unknownPropertiesKeySchema = (0, import_type_guards.isDefined)(schema.unknownPropertiesKey) && (!(0, import_type_guards.isArray)(schema.unknownPropertiesKey) || schema.unknownPropertiesKey.length > 0) ? (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.schemaTestablesToSchemas)(propertyValueType)),
-    mask: schema.mask,
-    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;
+    const unknownPropertiesSchema = (isDefined(schema.unknownProperties) && (!isArray(schema.unknownProperties) || (schema.unknownProperties.length > 0))) ? schemaTestablesToSchemas(schema.unknownProperties) : undefined;
+    const unknownPropertiesKeySchema = (isDefined(schema.unknownPropertiesKey) && (!isArray(schema.unknownPropertiesKey) || (schema.unknownPropertiesKey.length > 0))) ? schemaTestablesToSchemas(schema.unknownPropertiesKey) : undefined;
+    const allowUnknownProperties = ((isArray(unknownPropertiesSchema) && (unknownPropertiesSchema.length > 0)) || isDefined(unknownPropertiesSchema));
+    const normalizedSchema = {
+        factory: schema.factory,
+        properties: mapObjectValues(schema.properties, (propertyValueType) => schemaTestablesToSchemas(propertyValueType)),
+        mask: schema.mask,
+        allowUnknownProperties,
+        unknownProperties: isArray(unknownPropertiesSchema) ? valueSchema(unknownPropertiesSchema) : unknownPropertiesSchema,
+        unknownPropertiesKey: isArray(unknownPropertiesKeySchema) ? valueSchema(unknownPropertiesKeySchema) : unknownPropertiesKeySchema
+    };
+    return normalizedSchema;
 }
 function _normalizeValueSchema(schema) {
-  const normalizedValueSchema = {
-    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,
-    coerce: schema.coerce ?? false,
-    coercers: /* @__PURE__ */ new Map(),
-    transformers: (0, import_array.toArray)(schema.transformers ?? []),
-    arrayConstraints: (0, import_array.toArray)(schema.arrayConstraints ?? []),
-    valueConstraints: (0, import_array.toArray)(schema.valueConstraints ?? [])
-  };
-  for (const coercer of (0, import_array.toArray)(schema.coercers ?? [])) {
-    for (const sourceType of (0, import_array.toArray)(coercer.sourceType)) {
-      if (!normalizedValueSchema.coercers.has(sourceType)) {
-        normalizedValueSchema.coercers.set(sourceType, []);
-      }
-      normalizedValueSchema.coercers.get(sourceType).push(coercer);
+    const normalizedValueSchema = {
+        schema: [...new Set(toArray(schema.schema))].map(schemaTestableToSchema),
+        array: schema.array ?? false,
+        optional: schema.optional ?? false,
+        nullable: schema.nullable ?? false,
+        coerce: schema.coerce ?? false,
+        coercers: new Map(),
+        transformers: toArray(schema.transformers ?? []),
+        arrayConstraints: toArray(schema.arrayConstraints ?? []),
+        valueConstraints: toArray(schema.valueConstraints ?? [])
+    };
+    for (const coercer of toArray(schema.coercers ?? [])) {
+        for (const sourceType of toArray(coercer.sourceType)) {
+            if (!normalizedValueSchema.coercers.has(sourceType)) {
+                normalizedValueSchema.coercers.set(sourceType, []);
+            }
+            normalizedValueSchema.coercers.get(sourceType).push(coercer);
+        }
     }
-  }
-  return normalizedValueSchema;
+    return normalizedValueSchema;
 }
 function _normalizeTypeSchema(schema) {
-  const normalizedSchema = {
-    foo: (0, import_types.resolveValueType)(schema.type)
-  };
-  return normalizedSchema;
+    const normalizedSchema = {
+        foo: resolveValueType(schema.type)
+    };
+    return normalizedSchema;
 }
 function _getArrayItemSchema(schema) {
-  const itemSchema = {
-    schema: schema.schema,
-    transformers: schema.transformers,
-    valueConstraints: schema.valueConstraints
-  };
-  return itemSchema;
+    const itemSchema = {
+        schema: schema.schema,
+        transformers: schema.transformers,
+        valueConstraints: schema.valueConstraints
+    };
+    return itemSchema;
 }
-function getObjectSchemaFromReflection(type) {
-  const schema = tryGetObjectSchemaFromReflection(type);
-  if ((0, import_type_guards.isNull)(schema)) {
-    throw new Error(`Could not get schema for ${type.name} from reflection data.`);
-  }
-  return schema;
+export function getObjectSchemaFromReflection(type) {
+    const schema = tryGetObjectSchemaFromReflection(type);
+    if (isNull(schema)) {
+        throw new Error(`Could not get schema for ${type.name} from reflection data.`);
+    }
+    return schema;
 }
 function _tryGetObjectSchemaFromReflection(type) {
-  const metadata = import_registry.reflectionRegistry.getMetadata(type);
-  if ((0, import_type_guards.isUndefined)(metadata)) {
-    return null;
-  }
-  const typeData = metadata.data.tryGet("schema") ?? {};
-  const dataSchema = (0, import_types.isTypeSchema)(typeData.schema) ? getObjectSchema(typeData.schema.type) : (0, import_types.isObjectSchema)(typeData.schema) ? typeData.schema : (0, import_type_guards.isFunction)(typeData.schema) ? getObjectSchema(typeData.schema) : void 0;
-  const schema = (0, import_types.objectSchema)({
-    sourceType: type,
-    factory: (0, import_type_guards.isDefined)(typeData.factory) ? { builder: typeData.factory } : { type },
-    properties: dataSchema?.properties ?? getObjectSchemaPropertiesFromReflection(metadata, type),
-    mask: typeData.mask ?? dataSchema?.mask,
-    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);
-    if ((0, import_type_guards.isNotNull)(prototype) && import_registry.reflectionRegistry.hasType(prototype)) {
-      const parentSchema = getObjectSchemaFromReflection(prototype);
-      return (0, import_assign.assign)(parentSchema, schema);
+    const metadata = reflectionRegistry.getMetadata(type);
+    if (isUndefined(metadata)) {
+        return null;
     }
-  }
-  return schema;
+    const typeData = metadata.data.tryGet('schema') ?? {};
+    const dataSchema = isTypeSchema(typeData.schema)
+        ? getObjectSchema(typeData.schema.type)
+        : isObjectSchema(typeData.schema)
+            ? typeData.schema
+            : isFunction(typeData.schema)
+                ? getObjectSchema(typeData.schema)
+                : undefined;
+    const schema = objectSchema({
+        sourceType: type,
+        factory: isDefined(typeData.factory) ? { builder: typeData.factory } : { type: type },
+        properties: dataSchema?.properties ?? getObjectSchemaPropertiesFromReflection(metadata, type),
+        mask: typeData.mask ?? dataSchema?.mask,
+        unknownProperties: ((isUndefined(typeData.unknownProperties) || (isArray(typeData.unknownProperties) && (typeData.unknownProperties.length == 0))) ? undefined : typeData.unknownProperties) ?? dataSchema?.unknownProperties,
+        unknownPropertiesKey: ((isUndefined(typeData.unknownPropertiesKey) || (isArray(typeData.unknownPropertiesKey) && (typeData.unknownPropertiesKey.length == 0))) ? undefined : typeData.unknownPropertiesKey) ?? dataSchema?.unknownPropertiesKey
+    });
+    if (isUndefined(dataSchema)) {
+        const prototype = Reflect.getPrototypeOf(type);
+        if (isNotNull(prototype) && reflectionRegistry.hasType(prototype)) {
+            const parentSchema = getObjectSchemaFromReflection(prototype);
+            return assign(parentSchema, schema);
+        }
+    }
+    return schema;
 }
 function getObjectSchemaPropertiesFromReflection(metadata, type) {
-  const properties = {};
-  for (const [key, propertyMetadata] of metadata.properties) {
-    const reflectionData = propertyMetadata.data.tryGet("schema");
-    const itemType = reflectionData?.schema;
-    const array = reflectionData?.array == true ? true : void 0;
-    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)}"`);
+    const properties = {};
+    for (const [key, propertyMetadata] of metadata.properties) {
+        const reflectionData = propertyMetadata.data.tryGet('schema');
+        const itemType = reflectionData?.schema;
+        const array = (reflectionData?.array == true) ? true : undefined;
+        if (array && (isUndefined(itemType) || (isArray(itemType) && (itemType.length == 0)))) {
+            throw new Error(`Item type missing on type ${type.name} at property "${String(key)}"`);
+        }
+        properties[key] = valueSchema(schemaTestablesToSchemas(itemType ?? propertyMetadata.type), {
+            array,
+            optional: reflectionData?.optional,
+            nullable: reflectionData?.nullable,
+            coerce: reflectionData?.coerce,
+            coercers: reflectionData?.coercers,
+            transformers: reflectionData?.transformers,
+            arrayConstraints: reflectionData?.arrayConstraints,
+            valueConstraints: reflectionData?.valueConstraints
+        });
     }
-    properties[key] = (0, import_types.valueSchema)((0, import_types.schemaTestablesToSchemas)(itemType ?? propertyMetadata.type), {
-      array,
-      optional: reflectionData?.optional,
-      nullable: reflectionData?.nullable,
-      coerce: reflectionData?.coerce,
-      coercers: reflectionData?.coercers,
-      transformers: reflectionData?.transformers,
-      arrayConstraints: reflectionData?.arrayConstraints,
-      valueConstraints: reflectionData?.valueConstraints
-    });
-  }
-  return properties;
+    return properties;
 }

package/schema/utils/value-type.js

@@ -1,79 +1,56 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var value_type_exports = {};
-__export(value_type_exports, {
-  getSchemaTypeNames: () => getSchemaTypeNames,
-  getSchemaValueTypes: () => getSchemaValueTypes,
-  getValueType: () => getValueType,
-  getValueTypeName: () => getValueTypeName,
-  includesValueType: () => includesValueType
-});
-module.exports = __toCommonJS(value_type_exports);
-var import_array = require("../../utils/array/array.js");
-var import_type_guards = require("../../utils/type-guards.js");
-var import_types = require("../types/types.js");
-const lowercaseTypesSet = /* @__PURE__ */ new Set([...import_types.primitiveConstructorSet, Object, Array]);
-function getValueType(value) {
-  if ((0, import_type_guards.isUndefined)(value)) {
-    return "undefined";
-  }
-  if ((0, import_type_guards.isNull)(value)) {
-    return "null";
-  }
-  return value.constructor;
+import { toArray } from '../../utils/array/array.js';
+import { isArray, isFunction, isNull, isString, isUndefined } from '../../utils/type-guards.js';
+import { isDeferredValueType, isObjectSchema, isTypeSchema, isValueSchema, primitiveConstructorSet, resolveValueType, resolveValueTypes } from '../types/types.js';
+const lowercaseTypesSet = new Set([...primitiveConstructorSet, Object, Array]);
+export function getValueType(value) {
+    if (isUndefined(value)) {
+        return 'undefined';
+    }
+    if (isNull(value)) {
+        return 'null';
+    }
+    return value.constructor;
 }
-function includesValueType(valueType, valueTypes) {
-  const resolvedValueTypes = (0, import_types.resolveValueTypes)(valueTypes);
-  const resolvedValueType = (0, import_types.resolveValueType)(valueType);
-  if ((0, import_type_guards.isArray)(resolvedValueTypes)) {
-    return resolvedValueTypes.includes(resolvedValueType);
-  }
-  return resolvedValueType == resolvedValueTypes;
+export function includesValueType(valueType, valueTypes) {
+    const resolvedValueTypes = resolveValueTypes(valueTypes);
+    const resolvedValueType = resolveValueType(valueType);
+    if (isArray(resolvedValueTypes)) {
+        return resolvedValueTypes.includes(resolvedValueType);
+    }
+    return resolvedValueType == resolvedValueTypes;
 }
-function getValueTypeName(valueType) {
-  const resolvedValueType = (0, import_types.resolveValueType)(valueType);
-  return (0, import_type_guards.isString)(resolvedValueType) ? resolvedValueType : lowercaseTypesSet.has(resolvedValueType) ? resolvedValueType.name.toLowerCase() : resolvedValueType.name;
+export function getValueTypeName(valueType) {
+    const resolvedValueType = resolveValueType(valueType);
+    return isString(resolvedValueType)
+        ? resolvedValueType
+        : lowercaseTypesSet.has(resolvedValueType)
+            ? resolvedValueType.name.toLowerCase()
+            : resolvedValueType.name;
 }
-function getSchemaTypeNames(schema) {
-  return getSchemaValueTypes(schema).map(getValueTypeName);
+export function getSchemaTypeNames(schema) {
+    return getSchemaValueTypes(schema).map(getValueTypeName);
 }
-function getSchemaValueTypes(schema) {
-  if ((0, import_types.isTypeSchema)(schema)) {
-    return [(0, import_types.resolveValueType)(schema.type)];
-  }
-  if ((0, import_type_guards.isFunction)(schema)) {
-    return [schema];
-  }
-  if ((0, import_type_guards.isString)(schema)) {
-    return [schema];
-  }
-  if ((0, import_types.isObjectSchema)(schema)) {
-    return [(0, import_types.resolveValueType)(schema.sourceType ?? Object)];
-  }
-  if ((0, import_types.isValueSchema)(schema)) {
-    return [...new Set((0, import_array.toArray)(schema.schema).flatMap(getSchemaValueTypes))];
-  }
-  if ((0, import_types.isDeferredValueType)(schema)) {
-    return getSchemaValueTypes((0, import_types.resolveValueType)(schema));
-  }
-  if ((0, import_type_guards.isArray)(schema)) {
-    return schema.flatMap(getSchemaValueTypes);
-  }
-  throw new Error("Unsupported schema");
+export function getSchemaValueTypes(schema) {
+    if (isTypeSchema(schema)) {
+        return [resolveValueType(schema.type)];
+    }
+    if (isFunction(schema)) {
+        return [schema];
+    }
+    if (isString(schema)) {
+        return [schema];
+    }
+    if (isObjectSchema(schema)) {
+        return [resolveValueType(schema.sourceType ?? Object)];
+    }
+    if (isValueSchema(schema)) {
+        return [...new Set(toArray(schema.schema).flatMap(getSchemaValueTypes))];
+    }
+    if (isDeferredValueType(schema)) {
+        return getSchemaValueTypes(resolveValueType(schema));
+    }
+    if (isArray(schema)) {
+        return schema.flatMap(getSchemaValueTypes);
+    }
+    throw new Error('Unsupported schema');
 }

package/search-index/elastic/config.js

@@ -1,56 +1,27 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var config_exports = {};
-__export(config_exports, {
-  ElasticSearchIndexConfig: () => ElasticSearchIndexConfig
-});
-module.exports = __toCommonJS(config_exports);
-var import_decorators = require("../../injector/decorators.js");
-var import_interfaces = require("../../injector/interfaces.js");
-var import_type_guards = require("../../utils/type-guards.js");
-var __decorate = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __metadata = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-var __param = function(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-};
-let ElasticSearchIndexConfig = class ElasticSearchIndexConfig2 {
-  indexName;
-  constructor(indexNameOrConfig) {
-    this.indexName = (0, import_type_guards.isString)(indexNameOrConfig) ? indexNameOrConfig : indexNameOrConfig.indexName;
-  }
+import { InjectArg, Injectable } from '../../injector/decorators.js';
+import { resolveArgumentType } from '../../injector/interfaces.js';
+import { isString } from '../../utils/type-guards.js';
+let ElasticSearchIndexConfig = class ElasticSearchIndexConfig {
+    indexName;
+    constructor(indexNameOrConfig) {
+        this.indexName = isString(indexNameOrConfig) ? indexNameOrConfig : indexNameOrConfig.indexName;
+    }
 };
 ElasticSearchIndexConfig = __decorate([
-  (0, import_decorators.Injectable)(),
-  __param(0, (0, import_decorators.InjectArg)()),
-  __metadata("design:paramtypes", [Object])
+    Injectable(),
+    __param(0, InjectArg()),
+    __metadata("design:paramtypes", [Object])
 ], ElasticSearchIndexConfig);
+export { ElasticSearchIndexConfig };

package/search-index/elastic/index.js

@@ -1,23 +1,6 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var elastic_exports = {};
-module.exports = __toCommonJS(elastic_exports);
-__reExport(elastic_exports, require("./config.js"), module.exports);
-__reExport(elastic_exports, require("./keyword-rewriter.js"), module.exports);
-__reExport(elastic_exports, require("./model/index.js"), module.exports);
-__reExport(elastic_exports, require("./module.js"), module.exports);
-__reExport(elastic_exports, require("./search-index.js"), module.exports);
-__reExport(elastic_exports, require("./types.js"), module.exports);
+export * from './config.js';
+export * from './keyword-rewriter.js';
+export * from './model/index.js';
+export * from './module.js';
+export * from './search-index.js';
+export * from './types.js';

package/search-index/elastic/keyword-rewriter.js

@@ -1,41 +1,18 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var keyword_rewriter_exports = {};
-__export(keyword_rewriter_exports, {
-  KeywordRewriter: () => KeywordRewriter
-});
-module.exports = __toCommonJS(keyword_rewriter_exports);
-class KeywordRewriter {
-  fields;
-  constructor(fields) {
-    this.fields = new Set(fields);
-  }
-  add(field) {
-    this.fields.add(field);
-  }
-  remove(field) {
-    this.fields.delete(field);
-  }
-  requiresRewrite(field) {
-    return this.fields.has(field);
-  }
-  rewriteIfRequired(field) {
-    return this.requiresRewrite(field) ? `${field}.keyword` : field;
-  }
+export class KeywordRewriter {
+    fields;
+    constructor(fields) {
+        this.fields = new Set(fields);
+    }
+    add(field) {
+        this.fields.add(field);
+    }
+    remove(field) {
+        this.fields.delete(field);
+    }
+    requiresRewrite(field) {
+        return this.fields.has(field);
+    }
+    rewriteIfRequired(field) {
+        return this.requiresRewrite(field) ? `${field}.keyword` : field;
+    }
 }

package/search-index/elastic/model/elastic-query.js

@@ -1,16 +1 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var elastic_query_exports = {};
-module.exports = __toCommonJS(elastic_query_exports);
+export {};

package/search-index/elastic/model/index-mapping.js

@@ -1,27 +1,5 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var index_mapping_exports = {};
-__export(index_mapping_exports, {
-  mergeElasticSearchMappings: () => mergeElasticSearchMappings
-});
-module.exports = __toCommonJS(index_mapping_exports);
-var import_merge = require("../../../utils/object/merge.js");
-function mergeElasticSearchMappings(mappings) {
-  return (0, import_merge.mergeObjects)(mappings);
+/* eslint-disable @typescript-eslint/naming-convention */
+import { mergeObjects } from '../../../utils/object/merge.js';
+export function mergeElasticSearchMappings(mappings) {
+    return mergeObjects(mappings);
 }