@bytebrand/export-cars 0.0.3 → 1.0.6

package/src/transformers/mobile.transformer.ts

@@ -0,0 +1,495 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { DataSchemes } from '@bytebrand/car-schema';
+import { get, isEmpty, isNil, set, toString, upperFirst } from 'lodash';
+import { MappingService } from '../services/mapping.service';
+import { MappingRules } from '../interfaces/mapping-rules.interface';
+import { UserService } from '../services/user.service';
+import { CarDescriptionFactory, DescriptionTypeEnum } from '@bytebrand/car-description';
+import { ConfigService } from '../services/config.service';
+import { isNotEmptyArray } from '../utils/validator.utils';
+
+const vinGenerator = require('vin-generator');
+
+@Injectable()
+export class MobileTransformer {
+  private readonly logger = new Logger(MobileTransformer.name);
+  private currentCar: DataSchemes.Car;
+
+  constructor(
+    private mappingService: MappingService,
+    private userService: UserService,
+    private configService: ConfigService,
+  ) {}
+
+  async transform(carData: DataSchemes.Car, images: unknown[]): Promise<unknown> {
+    this.currentCar = carData;
+    const transformedCarData = {};
+    const rules = await this.mappingService.getRules();
+    for (const rule of rules) {
+      if (rule.custom === 'yes') {
+        const transformedField = await this.customTransformers(rule, carData, images);
+        if (transformedField) {
+          set(transformedCarData, `${rule.importField}`, transformedField);
+        }
+      } else {
+        const fieldValue: any = get(carData, `${rule.autodeField}`, null);
+        if (rule.autodeField === 'driveSuspension.gearbox' || rule.autodeField === 'mainData.mileage') {
+          set(transformedCarData, `${rule.importField}`, await this.customTransformers(rule, carData, images));
+        } else {
+          if (!isNil(fieldValue)) {
+            const transformedField = await this.transformField(fieldValue, rule);
+
+            if (!isNil(transformedField)) {
+              set(transformedCarData, `${rule.importField}`, transformedField);
+            }
+          }
+        }
+      }
+    }
+
+    set(transformedCarData, 150, toString(get(carData, 'rate.monthlyInstallment', '')));
+    set(transformedCarData, 293, toString(get(carData, 'leasing.monthlyInstallment', '')));
+    set(transformedCarData, 1, get(carData, 'metaData.vehicleId', null));
+
+    return transformedCarData;
+  }
+
+  private async transformField(fieldValue: any, rule: MappingRules): Promise<string | void> {
+    const transformProcedureName = `${rule.autodeFieldType}To${upperFirst(rule.importFieldType)}`;
+
+    switch (transformProcedureName) {
+      case 'stringToString': {
+        if (rule.autodeField === 'offer.offerDescription') {
+          return await this.offerStringToString();
+        }
+        return this.stringToString(fieldValue);
+      }
+      case 'integerToString': {
+        return this.numberToString(fieldValue);
+      }
+      case 'numberToString': {
+        return this.numberToString(fieldValue);
+      }
+      case 'booleanToString': {
+        return this.booleanToString(fieldValue);
+      }
+      case 'selectorToSelector': {
+        return this.selectorToSelector(fieldValue, rule);
+      }
+      case 'selectorToString': {
+        return this.selectorToString(fieldValue, rule);
+      }
+      case 'selector[]ToSelector': {
+        return this.selectorArrayToSelector(fieldValue, rule);
+      }
+      case 'selector[]ToString': {
+        return this.selectorArrayToString(fieldValue, rule);
+      }
+      case 'dateToString': {
+        return this.dateToString(fieldValue, rule);
+      }
+      case 'dateToMobile_delivery': {
+        return this.dateToString(fieldValue, rule);
+      }
+      case 'stringToMobile_model': {
+        return this.stringToMobile_model(fieldValue);
+      }
+      case 'numberToMobile_consumption': {
+        return this.numberToMobile_consumption(fieldValue);
+      }
+      case 'booleanToMobile_vatCalc': {
+        return this.booleanToMobile_vatCalc(fieldValue);
+      }
+      case 'selectorToMobile_extColor_selector': {
+        return this.selectorToSelector(fieldValue, rule);
+      }
+      case 'selectorToCategoryOrClass_selector': {
+        return this.selectorToCategoryOrClass_selector(fieldValue);
+      }
+      default:
+        this.logger.log(`missing transform: ${transformProcedureName}`);
+        break;
+    }
+  }
+
+  private async offerStringToString(): Promise<string> {
+    const dealerId = get(this.currentCar, 'metaData.ownerId');
+    const descriptionSchema = await this.userService.getDefaultSummaryByDealerId(dealerId);
+    const descriptionBuilder = CarDescriptionFactory.create(DescriptionTypeEnum.Mobile, this.currentCar);
+    return descriptionBuilder.transform(descriptionSchema);
+  }
+
+  private async customTransformers(rule: MappingRules, car: DataSchemes.Car, images: unknown[]): Promise<unknown> {
+    switch (rule.autodeField) {
+      case 'image': {
+        return this.getImages(car, images);
+      }
+      case 'autodeUrl': {
+        return this.getAutodeUrl(car);
+      }
+      case 'persistentId': {
+        return this.getPersistentId();
+      }
+      case 'price.vatDeductible': {
+        return this.getVatDeductible(car);
+      }
+      case 'mainData.numberOfPreviousOwners': {
+        return this.getNumberOfPreviousOwners(car);
+      }
+      case 'mainData.condition': {
+        return this.getUsageType(car);
+      }
+      case 'price.vatRate': {
+        return this.getVatRate(car);
+      }
+      case 'price.currentSalesPrice': {
+        return this.getCurrentSalesPrice(car);
+      }
+      case 'driveSuspension.gearbox': {
+        return this.getGearBox(car);
+      }
+      case 'mainData.mileage': {
+        return this.getMilage(car);
+      }
+      case 'consumption.consumptionPowerCombined': {
+        return this.getWLTP(car);
+      }
+      case 'environmentEmissions.emissionClass': {
+        return this.getEmissionClass(car);
+      }
+      case 'environmentEmissions.energyEfficiencyClass': {
+        return this.getEnergyEfficiencyClass(car);
+      }
+      case 'environmentEmissions.emissionSticker': {
+        return this.getEmissionSticker(car);
+      }
+      case 'environmentEmissions.co2': {
+        return this.getCO2(car);
+      }
+      case 'metaData.vin': {
+        return this.getVinCode(car);
+      }
+      default:
+        return '';
+    }
+  }
+
+  private getPersistentId() {
+    switch (this.configService.config.campaign) {
+      case 'eauto':
+        return '416';
+      default:
+        return '04109003';
+    }
+  }
+
+  private getVatDeductible(car: DataSchemes.Car): string {
+    return this.booleanToString(!get(car, 'price.vatDeductible', false));
+  }
+
+  private getWLTP(car: DataSchemes.Car): string | void {
+    const envkvCompliant = get(car, 'consumption.envkvCompliant');
+    const hybridPlagin = get(car, 'engineData.hybridPlugin');
+
+    if (envkvCompliant && hybridPlagin) {
+      const powerCombined = get(car, 'consumption.consumptionPowerCombined');
+      return String(powerCombined);
+    }
+  }
+
+  private getEmissionClass(car: DataSchemes.Car): string | void {
+    const emissionClass = get(car, 'environmentEmissions.emissionClass', 'selector_unknown');
+    switch (emissionClass) {
+      case 'selector_emissionClass_euro1': {
+        return '1';
+      }
+      case 'selector_emissionClass_euro2': {
+        return '2';
+      }
+      case 'selector_emissionClass_euro3': {
+        return '3';
+      }
+      case 'selector_emissionClass_euro4':
+      case 'selector_unknown': {
+        return '4';
+      }
+      case 'selector_emissionClass_euro5': {
+        return '5';
+      }
+      case 'selector_emissionClass_euro6': {
+        return '6';
+      }
+      case 'selector_emissionClass_euro6b': {
+        return '6b';
+      }
+      case 'selector_emissionClass_euro6c': {
+        return '6c';
+      }
+      case 'selector_emissionClass_euro6d': {
+        return '6d';
+      }
+      case 'selector_emissionClass_euro6d_temp': {
+        return '6d-TEMP';
+      }
+    }
+  }
+
+  private getEnergyEfficiencyClass(car: DataSchemes.Car): string {
+    const energyEfficiencyClass = get(car, 'environmentEmissions.energyEfficiencyClass', 'selector_unknown');
+    switch (energyEfficiencyClass) {
+      case 'selector_energyEfficiencyClass_appp': {
+        return 'A+++';
+      }
+      case 'selector_energyEfficiencyClass_app': {
+        return 'A++';
+      }
+      case 'selector_energyEfficiencyClass_ap': {
+        return 'A+';
+      }
+      case 'selector_unknown':
+      case null: {
+        return 'C';
+      }
+      default: {
+        return energyEfficiencyClass.slice(-1).toUpperCase();
+      }
+    }
+  }
+
+  private getEmissionSticker(car: DataSchemes.Car): string | void {
+    const emissionSticker = get(car, 'environmentEmissions.emissionSticker', 'selector_unknown');
+    switch (emissionSticker) {
+      case 'selector_emissionSticker_no': {
+        return '1';
+      }
+      case 'selector_emissionSticker_red': {
+        return '2';
+      }
+      case 'selector_emissionSticker_yellow':
+      case 'selector_unknown': {
+        return '3';
+      }
+      case 'selector_emissionSticker_green': {
+        return '4';
+      }
+    }
+  }
+
+  private getCO2(car: DataSchemes.Car): string {
+    const consumptionFuel = get(car, 'consumption.fuel', 'selector_unknown');
+    if (consumptionFuel === 'selector_fuel_electrical') {
+      return '0';
+    }
+    return String(get(car, 'environmentEmissions.co2'));
+  }
+
+  private getNumberOfPreviousOwners(car: DataSchemes.Car): string {
+    const usageType = this.getUsageType(car);
+    if (usageType === '1' || !get(car, 'mainData.numberOfPreviousOwners')) {
+      return '0';
+    }
+    return String(get(car, 'mainData.numberOfPreviousOwners'));
+  }
+
+  private getUsageType(car: DataSchemes.Car): string {
+    const firstRegistration = get(car, 'mainData.firstRegistration');
+    if (firstRegistration) {
+      return '0';
+    }
+    return '1';
+  }
+
+  private getVatRate(car: DataSchemes.Car): string {
+    const isVatDeductible = get(car, 'price.vatDeductible', false);
+    if (isVatDeductible) {
+      return String(get(car, 'price.vatRate', 19));
+    }
+    return '0';
+  }
+
+  private getCurrentSalesPrice(car: DataSchemes.Car): string {
+    const vat = get(car, 'price.vatDeductible', false);
+    const currentSalesPrice = get(car, 'price.currentSalesPrice', null);
+    if (vat) {
+      const vatRate = get(car, 'price.vatRate', 19);
+      const price = (currentSalesPrice * 100) / (100 + vatRate);
+      return String(price.toFixed(2));
+    }
+    return String(currentSalesPrice);
+  }
+
+  private getVinCode(car: DataSchemes.Car): string {
+    const vin = get(car, 'metaData.vin', '');
+
+    if (this.configService.config.campaign === 'marktde' && !vin) {
+      const fakeVin = get(car, 'marketing.fakeVIN', '');
+      if (!isEmpty(fakeVin)) {
+        return fakeVin;
+      }
+      return vinGenerator.generateVin();
+    }
+
+    return vin;
+  }
+
+  private getAutodeUrl(car: DataSchemes.Car): string {
+    return `${this.configService.config.carDetailsUrl}${car._id}?source=classifieds&medium=listing&campaign=${this.configService.config.campaign}`;
+  }
+
+  private getImages(car: DataSchemes.Car, images: unknown[]): string | null {
+    let res;
+    try {
+      res = this.getImagesField(car._id, get(car, 'metaData.mainImageId', null), images);
+    } catch (e) {
+      this.logger.error(e);
+      throw e;
+    }
+    let imagesAsALine;
+    if (isNotEmptyArray(res)) {
+      imagesAsALine = res.map((el: { url: string }) => el.url).join(';');
+    }
+    return imagesAsALine || null;
+  }
+
+  private stringToString(fieldValue: string): string {
+    return isEmpty(fieldValue) ? null : fieldValue;
+  }
+
+  private numberToString(fieldValue: number): string {
+    return String(fieldValue);
+  }
+
+  private booleanToString(fieldValue: boolean): string {
+    return String(Number(fieldValue));
+  }
+
+  private selectorToSelector(fieldValue: string, rule: MappingRules): string | void {
+    if (fieldValue === 'selector_unknown' && rule.autodeField === 'heatingCooling.climatisation') {
+      return '';
+    }
+
+    if (fieldValue === 'selector_unknown' || fieldValue === 'selector_interiorColor_rainbow') {
+      return '';
+    }
+    const pairs = rule.selectors.map(p => p.split(':').reverse());
+    const [match] = pairs.filter(p => p[0] === fieldValue);
+    // consider adding values not mapped in table
+    if (match) {
+      return match[1];
+    }
+  }
+
+  private selectorToString(fieldValue: string, rule: MappingRules): string {
+    return this.booleanToString(fieldValue === rule.autodeFieldSelector);
+  }
+
+  private selectorArrayToSelector(fieldValue: string[], rule: MappingRules): string | void {
+    const lastVal = fieldValue[fieldValue.length - 1];
+    const match = this.selectorToSelector(lastVal, rule);
+
+    if (match && match !== 'default') {
+      return match;
+    }
+  }
+
+  private selectorArrayToString(fieldValue: string[], rule: MappingRules): string {
+    const match = fieldValue.includes(rule.autodeFieldSelector);
+    return this.booleanToString(match);
+  }
+
+  private dateToString(fieldValue: number, rule: MappingRules): string {
+    const date = new Date(fieldValue * 1000);
+    if (["['6']", "['7']", "['8']"].includes(rule.importField)) {
+      return `${date.getMonth() + 1}.${date.getFullYear()}`;
+    }
+    return `${date.getDate()}.${date.getMonth() + 1}.${date.getFullYear()}`;
+  }
+
+  private stringToMobile_model(fieldValue: string): string {
+    const model = fieldValue;
+    const subModel = get(this.currentCar, 'mainData.subModel');
+    return subModel && subModel !== model ? `${model} ${subModel}` : model;
+  }
+
+  private numberToMobile_consumption(fieldValue: number): string {
+    const consumption = this.numberToString(fieldValue);
+    return consumption.replace('.', ',');
+  }
+
+  private booleanToMobile_vatCalc(fieldValue: boolean): string {
+    return this.booleanToString(!fieldValue);
+  }
+
+  private selectorToCategoryOrClass_selector(fieldValue: string): string {
+    const rules: { [key: string]: string } = {
+      selector_category_convertible: 'Cabrio',
+      selector_category_combi: 'Kombi',
+      selector_category_sedan: 'Limousine',
+      selector_category_suv: 'OffRoad',
+      selector_category_compact: 'SmallCar',
+      selector_category_coupe: 'SportsCar',
+      selector_category_van: 'Van',
+      selector_category_minibus: 'Van',
+      selector_category_transporter: 'OtherCar',
+      selector_unknown: 'OtherCar',
+    };
+
+    const found = rules[fieldValue];
+    if (found) {
+      return `Car.${found}`;
+    } else {
+      this.logger.log(`Missing mapping for: ${fieldValue}`);
+      return 'Car.OtherCar';
+    }
+  }
+
+  private getGearBox(car: DataSchemes.Car): unknown {
+    const rules: { [x: string]: string } = {
+      selector_gearbox_manualShift: '1',
+      selector_gearbox_semiAutomatic: '2',
+      selector_gearbox_automatic: '3',
+      selector_unknown: '0',
+    };
+    const autodeGearboxSelector = get(car, 'driveSuspension.gearbox', 'selector_unknown');
+
+    return rules[autodeGearboxSelector];
+  }
+
+  private getMilage(car: DataSchemes.Car): string {
+    // TODO:: fix if cbd
+    const mileage = car.mainData.mileage;
+    if (mileage <= 0) {
+      return '0';
+    }
+    return mileage.toString();
+  }
+
+  private getImagesField(carId: string, mainImageId: string, images: unknown[]): { url: string }[] {
+    const defImages = [
+      { url: 'https://images.auto.de/carimage/noimage/7pNvWELuWhZX/large-cached.jpeg' },
+      { url: 'https://images.auto.de/carimage/noimage/GvyXmrpaf1D6/large-cached.jpeg' },
+      { url: 'https://images.auto.de/carimage/noimage/gY1zF8PXzH2W/large-cached.jpeg' },
+      { url: 'https://images.auto.de/carimage/noimage/pFyfBsqBHEso/large-cached.jpeg' },
+    ];
+    if (isNotEmptyArray(images)) {
+      const imageList = images.sort(this.setMainImageFirst(mainImageId)).map((image: any) => {
+        return { url: this.buildLargeImageUrl(carId, image.imageIdentifier) };
+      });
+      return imageList;
+    }
+    return defImages;
+  }
+
+  private buildLargeImageUrl(carId: string, imageId: string): string {
+    const format = this.configService.config.campaign === 'eauto' ? 'jpeg' : 'webp';
+    return `${this.configService.config.imageUrl}/${carId}/${imageId}/large-cached.${format}`;
+  }
+
+  private setMainImageFirst(mainImageId: string): (current: any, next: any) => number {
+    return (current: any, next: any): number => {
+      if (current.imageIdentifier === mainImageId) return -1;
+      if (next.imageIdentifier === mainImageId) return 1;
+      return 0;
+    };
+  }
+}

package/src/transformers/ooyyo.transformer.ts

@@ -0,0 +1,123 @@
+import { Translator } from '@bytebrand/schema-tools';
+import { de } from '@bytebrand/i18n-dictionaries';
+import { get, toString, isEmpty, trim, join } from 'lodash';
+import * as moment from 'moment';
+import { DataSchemes } from '@bytebrand/car-schema';
+import { OoyyoXmlItem } from '../interfaces/export-item.interface';
+import { ImboImageResponseInterface } from '@bytebrand/chunkable';
+import { ConfigService } from '../services/config.service';
+import { Injectable } from '@nestjs/common';
+import { isNotEmptyArray } from '../utils/validator.utils';
+
+@Injectable()
+export class OoyyoTransformer {
+  private translator: Translator;
+
+  constructor(private configService: ConfigService) {
+    this.translator = new Translator(de);
+  }
+
+  transform(car: DataSchemes.Car, imboImages: ImboImageResponseInterface[]): OoyyoXmlItem {
+    const autodeid = toString(get(car, '_id', ''));
+    const creationDate = get(car, 'metaData.creationDate') as number;
+    const constructionYear = get(car, 'mainData.constructionYear') as number;
+    const firstRegistration = get(car, 'mainData.firstRegistration') as number;
+    const isNew = get(car, 'mainData.condition') === 'selector_condition_new';
+    let year = firstRegistration ? moment(firstRegistration * 1000).format('YYYY') : constructionYear;
+
+    if (!year && isNew) {
+      year = moment().subtract(2, 'months').format('YYYY');
+    }
+
+    return {
+      url: `https://www.${this.configService.config.url}/search/vehicle/${autodeid}`,
+      title: this.getTitle(car),
+      content: trim(toString(get(car, 'offer.offerDescription', ''))),
+      price: toString(get(car, 'price.currentSalesPrice', '')),
+      make: toString(get(car, 'mainData.make', '')),
+      model: toString(get(car, 'mainData.model', '')),
+      engine_size: toString(get(car, 'engineData.cubicCapacity', '')),
+      trim: toString(get(car, 'mainData.subModel', '')),
+      body_type: this.translateSelector(get(car, 'mainData.category', '')),
+      color: this.translateSelector(get(car, 'exterior.exteriorColor', '')).replace('Außenfarbe ', ''),
+      year: toString(year),
+      mileage: toString(get(car, 'mainData.mileage', '')),
+      fuel_type: this.translateSelector(get(car, 'consumption.fuel', '')),
+      transmission: this.translateSelector(get(car, 'driveSuspension.gearbox', '')),
+      euronorm: this.getEmissionClass(car),
+      power: toString(get(car, 'engineData.powerKW', '')),
+      doors: toString(get(car, 'mainData.doors', '')),
+      seats: toString(get(car, 'mainData.seats', '')),
+      gears: toString(get(car, 'driveSuspension.gears', '')),
+      pictures: this.getImagesField(autodeid, imboImages),
+      location: {
+        city: toString(get(car, 'location.city', '')),
+        postcode: toString(get(car, 'location.zipCode', '')),
+        region: toString(get(car, 'location.countryCode', '')),
+      },
+      vin: toString(get(car, 'metaData.vin', '')),
+      is_new: this.getCondition(car),
+      date: this.formatTimestamp(creationDate),
+      time: this.formatTimestamp(creationDate, true),
+    };
+  }
+
+  private getTitle(car: DataSchemes.Car): string {
+    const year = toString(get(car, 'mainData.constructionYear', ''));
+    const make = toString(get(car, 'mainData.make', ''));
+    const model = toString(get(car, 'mainData.model', ''));
+    const subModel = toString(get(car, 'mainData.subModel', ''));
+    return trim(join([year, make, model, subModel], ' '));
+  }
+
+  private getCondition(car: DataSchemes.Car): string {
+    const conditionSelector = get(car, 'mainData.condition', '');
+    return conditionSelector === 'selector_condition_new' ? '1' : '0';
+  }
+
+  private translateSelector(selector: string): string {
+    if (isEmpty(selector) || selector === 'selector_unknown') {
+      return '';
+    }
+    return this.translator.translateVal(selector);
+  }
+
+  private getEmissionClass(car: DataSchemes.Car): string {
+    const available = {
+      selector_emissionClass_euro1: '1',
+      selector_emissionClass_euro2: '2',
+      selector_emissionClass_euro3: '3',
+      selector_emissionClass_euro4: '4',
+      selector_emissionClass_euro5: '5',
+      selector_emissionClass_euro6: '6',
+      selector_emissionClass_euro6b: '6b',
+      selector_emissionClass_euro6c: '6c',
+      selector_emissionClass_euro6d: '6d',
+      selector_emissionClass_euro6d_temp: '6d-TEMP',
+      selector_unknown: 'default',
+    };
+    const emissionClass = get(car, 'environmentEmissions.emissionClass', 'selector_unknown');
+    return get(available, emissionClass);
+  }
+
+  private formatTimestamp(timestamp: number, onlyTime = false): string {
+    if (!timestamp) {
+      return '';
+    }
+    const format = onlyTime ? 'hh:mm:ss' : 'DD/MM/YYYY';
+    return moment(timestamp * 1000).format(format);
+  }
+
+  private getImagesField(carId: string, images: ImboImageResponseInterface[]): string[] {
+    if (isNotEmptyArray(images)) {
+      return images.map((image: ImboImageResponseInterface) => {
+        return this.buildLargeImageUrl(carId, image.imageIdentifier);
+      });
+    }
+    return [];
+  }
+
+  private buildLargeImageUrl(carId: string, imageId: string): string {
+    return `${this.configService.config.url}/carimage/${carId}/${imageId}/large`;
+  }
+}

package/src/utils/converter.utils.ts

@@ -0,0 +1,11 @@
+import { set } from 'lodash';
+
+export function convertToCSV(data: unknown): string {
+  const converted = [];
+  Object.entries(data).forEach(e => {
+    const [k, v] = e as string[];
+    const vCleared = (v || '').replace(new RegExp('"', 'gm'), '""');
+    set(converted, k, `"${vCleared}"`);
+  });
+  return converted.join(';');
+}

package/src/utils/date-time.utils.ts

@@ -0,0 +1,20 @@
+export function getMonthsDiff(date1: Date, date2: Date): number {
+  let start_date = date1;
+  let end_date = date2;
+  let inverse = false;
+
+  if (date1 > date2) {
+    start_date = date2;
+    end_date = date1;
+    inverse = true;
+  }
+
+  end_date = new Date(end_date);
+  end_date.setDate(end_date.getDate() + 1);
+
+  const yearsDifference = end_date.getFullYear() - start_date.getFullYear();
+  const monthsDifference = end_date.getMonth() - start_date.getMonth();
+  const daysDifference = end_date.getDate() - start_date.getDate();
+
+  return (inverse ? -1 : 1) * (yearsDifference * 12 + monthsDifference + daysDifference / 30);
+}

package/src/utils/parser.utils.ts

@@ -0,0 +1,6 @@
+import { RuleParser } from '../interfaces/rule-parser.interface';
+
+export function parseFields<T>(values: string, fc: RuleParser<T>): T[] {
+  const fieldsArr: string[] = values.split(',');
+  return fieldsArr.map((e: string): T => fc(e));
+}

package/src/utils/validator.utils.ts

@@ -0,0 +1,7 @@
+export function isValidVin(vin: string): boolean {
+  return !!vin && vin.length === 17;
+}
+
+export function isNotEmptyArray(array: unknown[]): boolean {
+  return array && Array.isArray(array) && !!array.length;
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}