@wayke-se/components-react 3.8.1 → 3.9.0-beta.2

package/dist-src/utils/vehicle-properties/compare-categories.js

@@ -1,27 +0,0 @@
-const ID_ORDER = Object.freeze({
-    '1000': 1,
-    '71': 2,
-    '2': 3,
-    '1': 4,
-    '8': 5,
-    '6': 6,
-    '119': 7,
-});
-const compareById = (firstId, secondId) => {
-    const firstOrder = ID_ORDER[firstId] || Number.MAX_SAFE_INTEGER;
-    const secondOrder = ID_ORDER[secondId] || Number.MAX_SAFE_INTEGER;
-    if (firstOrder < secondOrder) {
-        return -1;
-    }
-    else if (secondOrder < firstOrder) {
-        return 1;
-    }
-    return 0;
-};
-export default (first, second) => {
-    const result = compareById(`${first.id}`, `${second.id}`);
-    if (result !== 0) {
-        return result;
-    }
-    return first.name.localeCompare(second.name);
-};

package/dist-src/utils/vehicle-properties/compare-properties.js

@@ -1,3 +0,0 @@
-export default (first, second) => {
-    return first.name.localeCompare(second.name);
-};

package/dist-src/utils/vehicle-properties/custom-property-adder.js

@@ -1,143 +0,0 @@
-import deepCopy from '../deep-copy';
-export const TEXT_TYPE = 'text';
-export const NUMBER_TYPE = 'number';
-export const BASIC_CATEGORY = Object.freeze({
-    id: 1000,
-    name: 'Basuppgifter',
-    subCategory: null,
-});
-export const ENGINE_SUBCATEGORY = Object.freeze({
-    id: 6,
-    name: 'Motor & Prestanda',
-    subCategory: {
-        id: 54,
-        name: 'Motor',
-        subCategory: null,
-    },
-});
-class PropertyBuilder {
-    constructor() {
-        this.name = '';
-        this.value = '';
-        this.type = 'unknown';
-        this.unit = null;
-        this.hint = null;
-        this.category = null;
-    }
-    withName(name) {
-        this.name = name;
-        return this;
-    }
-    withValue(value) {
-        this.value = value;
-        return this;
-    }
-    withType(type) {
-        this.type = type;
-        return this;
-    }
-    withCategory(category) {
-        this.category = category;
-        return this;
-    }
-    withUnit(unit) {
-        this.unit = unit;
-        return this;
-    }
-    build() {
-        return {
-            name: this.name,
-            value: this.value,
-            type: this.type,
-            unit: this.unit,
-            hint: this.hint,
-            category: this.category,
-        };
-    }
-}
-export default (item, properties) => {
-    const newProperties = deepCopy(properties);
-    if (!!item.manufacturer) {
-        newProperties.manufacturer = new PropertyBuilder()
-            .withName('Varumärke')
-            .withValue(item.manufacturer)
-            .withType(TEXT_TYPE)
-            .withCategory(BASIC_CATEGORY)
-            .build();
-    }
-    if (!!item.modelSeries) {
-        newProperties.modelSeries = new PropertyBuilder()
-            .withName('Modell')
-            .withValue(item.modelSeries)
-            .withType(TEXT_TYPE)
-            .withCategory(BASIC_CATEGORY)
-            .build();
-    }
-    if (!!item.modelName) {
-        newProperties.modelName = new PropertyBuilder()
-            .withName('Version')
-            .withValue(item.modelName)
-            .withType(TEXT_TYPE)
-            .withCategory(BASIC_CATEGORY)
-            .build();
-    }
-    if (!!item.modelYear) {
-        newProperties.modelYear = new PropertyBuilder()
-            .withName('Modellår')
-            .withValue(item.modelYear)
-            .withType(NUMBER_TYPE)
-            .withCategory(BASIC_CATEGORY)
-            .build();
-    }
-    if (!!item.manufactureYear) {
-        newProperties.manufactureYear = new PropertyBuilder()
-            .withName('Tillverkningsår')
-            .withValue(item.manufactureYear)
-            .withType(NUMBER_TYPE)
-            .withCategory(BASIC_CATEGORY)
-            .build();
-    }
-    if (!!item.mileage) {
-        newProperties.mileage = new PropertyBuilder()
-            .withName('Mätarställning')
-            .withValue(item.mileage)
-            .withType(NUMBER_TYPE)
-            .withCategory(BASIC_CATEGORY)
-            .withUnit('mil')
-            .build();
-    }
-    if (!!item.gearboxType) {
-        newProperties.gearboxType = new PropertyBuilder()
-            .withName('Växellåda')
-            .withValue(item.gearboxType)
-            .withType(TEXT_TYPE)
-            .withCategory(BASIC_CATEGORY)
-            .build();
-    }
-    if (!!item.registrationNumber) {
-        newProperties.registrationNumber = new PropertyBuilder()
-            .withName('Registreringsnummer')
-            .withValue(item.registrationNumber)
-            .withType(TEXT_TYPE)
-            .withCategory(BASIC_CATEGORY)
-            .build();
-    }
-    if (!!item.fuelType) {
-        newProperties.fuelType = new PropertyBuilder()
-            .withName('Bränslegrupp')
-            .withValue(item.fuelType)
-            .withType(TEXT_TYPE)
-            .withCategory(BASIC_CATEGORY)
-            .build();
-    }
-    if (item.enginePower) {
-        newProperties.enginePower = new PropertyBuilder()
-            .withName('Effekt')
-            .withValue(item.enginePower)
-            .withUnit('hk')
-            .withType(NUMBER_TYPE)
-            .withCategory(ENGINE_SUBCATEGORY)
-            .build();
-    }
-    return newProperties;
-};

package/dist-src/utils/vehicle-properties/property-hint-enricher.js

@@ -1,192 +0,0 @@
-import deepCopy from '../deep-copy';
-export const HINTS = Object.freeze({
-    abs: 'Förhindrar att bromsarna låser sig och reducerar bromssträckan.',
-    acceleration: 'Antal sekunder som bilen behöver för att ta sig till 100 km/h.',
-    adultOccupantNCAP: 'Poängen för skydd av vuxna bestäms genom tester av frontalkrockar, sidokrockar och whiplash som utförs för att bedöma det skydd som bilen erbjuder för vuxna förare och passagerare samt bedöma tillgängliga åtgärder för snabb och säker räddning.',
-    aeb: 'Bilen är utrustad med ett bromssystem som hjälper dig att undvika olyckor. Beroende på vilken nivå av AEB bilen är utrustad med kan de upptäcka även cyklister och fotgängare, främst i lägre hastigheter i stadsmiljö men även vid högre hastigheter och landsvägskörning. Bilen förvarnar föraren om potentiell fara och hjälper även till att bromsa för att säkerställa att olyckor undviks så långt det går.',
-    airbagCutOffSwitch: 'Det går att koppla ur krockkudden på passagerarsidan för att kunna sätta dit en barnstol.',
-    airbagDriver: 'Krockkudde för föraren.',
-    airbagFrontal: '',
-    airbagFrontalHead: '',
-    airbagKnees: '',
-    airbagPassenger: 'Krockkudde för passagerare.',
-    airbagSideChest: '',
-    airbagSidePelvis: '',
-    alcolock: 'För att kunna starta bilen behövs ett blåstest som mäter alkoholnivån.',
-    androidAuto: 'Bilen har stöd för dig med Androidtelefon att koppla upp den direkt till bilen. Då följer bland annat navigering, meddelanden samt musiken med från telefonen.',
-    annualBonus: 'Det här fordonet är berättigat till klimatbonus. Bonusen delas ut till den första registrerade ägaren efter 6 månader. Klicka <a target="_blank" rel="noopener noreferrer" title="Läs mer om bonus/malus" href="https://www.transportstyrelsen.se/bonusmalus">här</a> för att läsa mer.',
-    annualMalus: 'Bilen har en förhöjd skatt de tre första åren och därefter gäller ordinarie skatt.',
-    annualTax: 'Summan fordonsskatt som måste betalas varje år.',
-    antiTheftAlarm: 'Bilen har ett larmsystem vid försök till inbrott.',
-    appConnect: 'Med App Connect kan du koppla din mobiltelefon så att anpassade appar syns direkt i bilens display. Fungerar både för iPhone och Android.',
-    appleCarPlay: 'Bilen har stöd för Apple i bilens inbyggda display, så du enkelt kan koppla upp din telefon och prata med bilen med hjälp av Siri.',
-    aux: 'Bilen har en AUX-ingång, för att exempelvis spela musik från en telefon.',
-    auxiliaryLamps: '',
-    batteryCapacity: 'Anger hur många kilowatt-timmar batteriet innehar.',
-    batteryWarrantyDistance: '',
-    batteryWarrantyTime: '',
-    blindSpotWarner: 'En varningslampa indikerar i ytterbackspegeln när ett fordon befinner sig i döda vinkeln.',
-    bluetooth: 'Bilen kan ansluta enheter via Bluetooth, för exempelvis mobilsamtal eller musik.',
-    bluetoothAudio: 'Bilen kan ansluta enheter via Bluetooth för att lyssna på musik.',
-    bluetoothPhone: 'Bilen kan ansluta enheter via Bluetooth för telefonsamtal.',
-    brakeAssistance: 'Säkerhetssystem som kan hjälpa till att bromsa och undvika olyckor.',
-    carDamageWarrantyDistance: '',
-    carDamageWarrantyTime: '',
-    centerDisplay: 'Bilen har en skärm mitt i bilen, mellan förare och passagerare.',
-    centralLocking: 'Elektriskt låssystem, som gör att alla dörrar låses och öppnas samtidigt.',
-    chargeTimeNormal: 'Hur lång tid tar det att ladda bilen i ett standard elnät.',
-    chargeTimeQuick: 'Hur lång tid tar det att ladda bilen med en snabbladdare anpassad för laddning av elbilar.',
-    chassis: 'Vilken typ/form bilen har.',
-    childOccupantNCAP: 'Bedömningen av skyddet av barn täcker tre viktiga aspekter: det skydd som erbjuds av bilbarnstolar i frontal- och sidokrockstest; fordonets möjligheter att inhysa bilbarnstolar med olika storlek och utformning; och tillgängliga åtgärder för säker transport av barn i bilen.',
-    childSafetyLocks: 'Dörrarna låses automatiskt när man kör iväg, så att de inte ska öppnas under körning.',
-    childSeatBeltPassenger: 'Passagerarsätet har utfällbar sittkudde för barn.',
-    childSeatBeltRear: 'Baksätet har utfällbar sittkudde för barn.',
-    co2: 'Anger hur mycket koldioxid fordonet släpper ut enligt mätmetoden NEDC baserat på teoretisk körning.',
-    colorName: '',
-    combinedEmissionsWLTP: 'Anger hur mycket koldioxid fordonet släpper ut enligt mätmetoden WLTP baserat på verklig körning.',
-    cruiseControl: 'Hjälpmedel som håller bilens hastighet automatiskt.',
-    curtainAirbags: '',
-    displacementCC: 'Den sammanlagda volymen av motorns cylindrar. Mäts i kubikcentimeter.',
-    displacementLitres: 'Den sammanlagda volymen av motorns cylindrar. Mäts i liter.',
-    driverAlertnessDetection: 'Varningssignal uppstår när körningssättet tyder på bristande uppmärksamhet.',
-    drivingWheel: 'Vilka hjul som motorn ger kraft till och snurrar.',
-    electricalEngine: '',
-    electricalRange: 'Räckvidd enligt mätmetoden WLTP baserat på verklig körning',
-    electricalRangeEPA: 'Räckvidd enligt den amerikanska mätmetoden EPA. Enligt många den allra strängaste metoden.',
-    electricalRangeNEDC: 'Räckvidd enligt mätmetoden NEDC baserat på teoretisk körning.',
-    electricalRangeWLTP: 'Räckvidd enligt mätmetoden WLTP baserat på verklig körning.',
-    electricalSeatDriver: 'Bilens förarstol går att manövrera med el för mjukare och mer precis positionering.',
-    electricalSeatPassenger: 'Bilens passagerarstol går att manövrera med el.',
-    emergencyCalling: 'Bilen kan automatiskt larma SOS vid en olycka.',
-    engineConfiguration: 'Anger fordonets typ av motor, vilken typ av cylindrar den innehar.',
-    engineCylinders: "Antalet ger en indikation på motorns storlek. Ett 'vanligt' antal ligger på 4 st.",
-    engineName: '',
-    engineVolume: '',
-    enrichmentProviderEquipPackages: '',
-    enrichmentProviderExteriorPackages: '',
-    enrichmentProviderInteriorPackages: '',
-    enrichmentProviderTrimPackages: '',
-    environmentClass: 'Används för att ställa krav på fordonets utsläpp.',
-    finish: '',
-    fuelConsumptionCityDriving: 'Bränsleförbrukning vid stadskörning.',
-    fuelConsumptionCountryRoadDriving: 'Bränsleförbrukning vid landsvägskörning.',
-    fuelConsumptionMixedDrivingNEDC: 'Bränsleförbrukning vid blandad körning.',
-    fuelConsumptionMixedDrivingWLTP: 'Bränsleförbrukning vid blandad körning.',
-    fuelConsumptionMixedDriving: 'Bränsleförbrukning vid blandad körning. Dvs. stadskörning och landsvägskörning under en och samma färd.',
-    fuelType: 'Vad bilen ska tankas med och drivs av.',
-    gearboxName: '',
-    gestureControls: 'Mittskärmen går att manövrera med rörelser.',
-    gps: 'Bilen är utrustad med navigationsutrustning så du enkelt kan ta dig dit du ska.',
-    grossWeight: 'Anger bilens vikt inklusive max tillåten lastvikt.',
-    groundClearence: 'Avståndet mellan bilens undersida och marken.',
-    hasAutomaticGearbox: '',
-    hdmi: 'Bilen har en HDMI-port.',
-    headRoomFront: 'Lägsta takhöjden i framsätet.',
-    headRoomRear: 'Lägsta takhöjden i baksätet.',
-    headUpDisplay: 'Bilen är utrustad med en projicerad display i ditt synfält, så du kan se exempelvis nuvarande hastighet utan att behöva vända bort blicken från vägen.',
-    heatedSteeringWheel: '',
-    height: 'Avståndet från bilens undersida till översida.',
-    hybridComponentsWarrantyDistance: '',
-    hybridComponentsWarrantyTime: '',
-    interiorMaterial: 'Material på interiören i bilen, dvs detaljer i bilens insida.',
-    isofixRearSeat: 'Universell fästanordning för barnstolar.',
-    keylessEntry: 'Bilens dörrar och bagage öppnas när den känner av att bilnyckeln är i närheten och du tar tag i handtaget. Du behöver därmed inte använda nyckeln i sig för att öppna bilens dörrar. ',
-    keylessStart: 'Bilen startas med ett knapptryck istället för att bilnyckeln behöver vridas om. Det räcker med att bilnyckeln befinner sig i bilen (kan du mao ha den i fickan hela bilresan).',
-    laneAssistance: 'Funktion som hjälper till att hålla bilen inom körfältet.',
-    legRoomFront: 'Avstånd mellan instrumentpanelen och framsäte.',
-    legRoomRear: 'Avstånd mellan framsätets rygg och baksätet',
-    length: 'Avståndet från bilens baksida till framsida.',
-    lowBeam: '',
-    mainBeam: '',
-    mainBeamAssistance: 'Bilen slår på och av helljuset per automatik, så du slipper göra det själv.',
-    manufactureYear: 'Året bilen tillverkades.',
-    massage: 'Bilens säte har inbyggd massage.',
-    maxLoadWeight: '',
-    maxRoofWeight: 'Hur många kilo last taket klarar av.',
-    maxSpeed: 'Högsta hastigheten som bilen går att köra.',
-    maxTrailerLoadBraked8Percent: '',
-    maxTrailerLoadUnbraked: 'Vikten du får dra på ett släp som inte är utrustat med egna bromsar.',
-    mildHybrid: 'Bilen är utrustad med en elmotor som fungerar både som startmotor och generator och stöttar förbränningsmotorn, vilket ger lägre bränsleförbrukning och därmed minskade utsläppsnivåer.',
-    mileage: 'Antal mil som bilen har körts. I bilen anges det i kilometer istället.',
-    modelName: 'Vilket utförande av bilmodellen det är.',
-    modelYear: 'Modellår sätts av tillverkaren. Handlaren ändrar ibland modellåret för att matcha transportstyrelsens definition för <i>årsmodell</i>. Definitionen för årsmodell innebär att bilar tillverkade andra halvan av året får nästa års modellår.',
-    ncapStar: 'Universellt säkerhetsbetyg för bilar, fler stjärnor innebär högre säkerhet. Skalan går från 0 till 5 där 5 är det högsta betyget. Så här beskriver Euro NCAP själva att slutbetyget ska utläsas: <br/>' +
-        '<br/>' +
-        '5 stjärnor: Som helhet utmärkt prestanda inom krockskydd och väl utrustad med omfattande teknik för att undvika kollisioner<br/><br/>' +
-        '4 stjärnor: Som helhet bra prestanda inom krockskydd, det kan finnas ytterligare teknik för att undvika kollisioner<br/><br/>' +
-        '3 stjärnor: Åtminstone genomsnittligt passagerarskydd men inte alltid utrustad med de senaste funktionerna för att undvika kollisioner<br/><br/>' +
-        '2 stjärnor: Nominellt krockskydd men saknar teknik för att undvika kollisioner<br/><br/>' +
-        '1 stjärna: Marginellt krockskydd och viss teknik för att undvika kollisioner<br/><br/>' +
-        '0 stjärnor: Uppfyller standarder för typgodkännande så att fordonet får säljas men saknar kritisk modern säkerhetsteknik.',
-    ncapYear: 'Året som bilen säkerhets- och krocktestades.',
-    newVehicleWarrantyDistance: '',
-    newVehicleWarrantyTime: '',
-    noiseReducingWindows: 'Bilens rutor är ljudisolerade för högre komfort.',
-    numberOfGears: 'Antal växlar i växellådan.',
-    numberOfSpeakers: 'Anger totalt antal högtalare i bilen, ju fler högtalare desto häftigare ljud!',
-    numberOfUSBPorts: '',
-    otherAirbags: '',
-    parkingAssistance: 'Funktion som assisterar vid fickparkering.',
-    parkingSensorsFront: 'Ljudsignal som indikerar när bilens främre del närmar sig ett objekt.',
-    parkingSensorsRear: 'Ljudsignal som indikerar när bilens bakre del närmar sig ett objekt.',
-    pedestrianNCAP: 'Euro NCAP bedömer hur väl bilar skyddar sina passagerare men testar även hur bilar skyddar oskyddade trafikanter – fotgängare och cyklister – som de kan kollidera med.',
-    preHeater: 'Värmer motorn när det är kallt ute för att underlätta start.',
-    rainSensors: 'Vindrutetorkarna aktiveras och anpassas automatiskt i förhållande till regnet.',
-    remoteStart: 'Möjliggör att du kan starta bilens motor med hjälp av exempelvis en app i telefonen',
-    rimSize: 'Fälgstorlek angivet i tum.',
-    roofColor: 'Någon del av bilen, ex taket skiljer sig i kulör mot övriga bilen.',
-    roofRailing: 'Bilen har takreling som du kan fästa takräcken i.',
-    safetyAssistNCAP: 'Poängen för förarstödsystem bestäms genom tester av de viktigaste förarstöd teknikerna som stöder säker körning för att undvika och begränsa olyckor.',
-    seats: 'Antal personer som får åka i bilen.',
-    segment: 'Vilken typ av bil det handlar om - t.ex. familjebil',
-    serviceWeight: 'Anger hur mycket bilen väger med en passagerare som väger ca 75kg.',
-    shoulderRoomFront: 'Avstånd i bredd för bilens framsäte.',
-    shoulderRoomRear: 'Avstånd i bredd för bilens baksäte.',
-    sideMirrorFolding: 'Bilens yttre backspeglar går att automatiskt fälla in, exempelvis bra på trånga parkeringar.',
-    speakerBrand: '',
-    startAndStop: 'Bilens motor stoppas när bilen står still för att minska utsläppen.',
-    steeringWheelMaterial: '',
-    sunRoof: '',
-    tankVolume: 'Antal liter bränsle som ryms i tanken.',
-    timingBeltServiceIntervalDistance: 'Bilen är utrustad med kamrem som måste bytas vid olika distansintervall.',
-    timingBeltServiceIntervalTime: 'Bilen är utrustad med kamrem som måste bytas vid olika tidsintervall.',
-    tintedWindows: 'Bilens rutor har en mörkare toning.',
-    tiresFront: 'Däckdimension fram. Presenteras i höjd/bredd och inom ett spann. Däcken som sitter på bilen måste alltså falla inom det spannet.',
-    tiresRear: 'Däckdimension bak. Presenteras i höjd/bredd och inom ett spann. Däcken som sitter på bilen måste alltså falla inom det spannet.',
-    torque: 'Bilens vridkraft. Hög siffra möjliggör att t.ex. dra tunga släp. Dieselmotorer har generellt mer vridmoment.',
-    touchScreen: 'Mittskärmen i bilen är en pekskärm.',
-    towHitch: '',
-    towHitchDetachable: '',
-    towHitchFoldable: '',
-    trafficSignRecognition: 'Bilen är utrustad med kameror som läser av gällande trafikskyltar.',
-    trailerTotalWeightB: 'Vikten man får dra med släp och ett vanligt B-körkort.',
-    transmissionKnobMaterial: '',
-    trcSystem: 'Får bilen att skicka kraft till hjulet som har bästa kontakt med underlaget.',
-    tripComputer: 'I färddatorn som sitter framför ratten kan du se lite information om motorn och bränsleförbrukningen, bland annat kan du ofta läsa ut den återstående körsträckan på nuvarande bränslevolym.',
-    trunkDepth: '',
-    trunkHeight: '',
-    trunkOutlet: '',
-    trunkSpace: 'Volym på bagageutrymmet med uppfällda säten. Det mäts i liter.',
-    trunkSpaceFront: '',
-    trunkWidth: '',
-    typeOfElectricCar: 'Anger om bilen drivs av el eller om den är en hybrid av el och bränsle.',
-    upholstery: '',
-    usb: 'Bilen är utrustad med en USB-port',
-    ventilatedSeats: 'Bilens stolar har ventilation inbyggd, bland annat bra för att få bort fukt från sätena.',
-    wheelBase: 'Avståndet mellan fram- och bakhjul.',
-    wiFi: 'Bilen är utrustad med ett internt WIFI som du kan koppla upp dina egna enheter mot.',
-    width: 'Avståndet mellan bilens båda yttre långsidor.',
-    windowLifts: '',
-    wirelessPhoneCharger: 'Bilen är utrustad med induktionsladdare, så att telefoner som stödjer trådlös laddning kan laddas i bilen utan laddningssladd.',
-});
-const enrichWithHint = (properties) => {
-    const clone = deepCopy(properties);
-    const keys = Object.keys(clone);
-    keys.forEach((key) => {
-        if (!!HINTS[key]) {
-            clone[key].hint = HINTS[key];
-        }
-    });
-    return clone;
-};
-export default enrichWithHint;

package/dist-src/utils/vehicle-properties/property-remover.js

@@ -1,27 +0,0 @@
-import deepCopy from '../deep-copy';
-const PROPERTY_BLACK_LIST = Object.freeze([
-    'towHitchFoldable',
-    'trailerTotalWeightB',
-    'gps',
-    'androidAuto',
-    'appleCarPlay',
-    'tintedWindows',
-]);
-const isForbiddenProperty = (key) => PROPERTY_BLACK_LIST.includes(key);
-const CATEGORY_WHITE_LIST = Object.freeze([1, 2, 6, 8, 71, 119, 1000]);
-const hasForbiddenCategory = (property) => !property.category ||
-    !property.category.id ||
-    !CATEGORY_WHITE_LIST.includes(property.category.id);
-export default (properties) => {
-    const newProperties = deepCopy(properties);
-    Object.keys(properties).forEach((key) => {
-        const property = properties[key];
-        if (hasForbiddenCategory(property)) {
-            delete newProperties[key];
-        }
-        else if (isForbiddenProperty(key)) {
-            delete newProperties[key];
-        }
-    });
-    return newProperties;
-};

package/dist-src/utils/vehicle-properties/property-tree-creator.js

@@ -1,127 +0,0 @@
-class PropertyTreeCreator {
-    constructor(properties) {
-        this.propertiesWithCategory = (propertyKey) => !!this.properties[propertyKey].category?.id;
-        this.propertiesWithoutCategory = (propertyKey) => !this.propertiesWithCategory(propertyKey);
-        this.isList = (property) => property.type === PropertyTreeCreator.TEXT_LIST_TYPE;
-        this.isNonList = (property) => !this.isList(property);
-        this.hasCategoryWithId = (propertyKey, categoryId) => this.properties[propertyKey].category?.id === categoryId;
-        this.propertiesWithSubCategory = (propertyKey) => !!this.properties[propertyKey].category?.subCategory?.id;
-        this.propertiesWithoutSubCategory = (propertyKey) => !this.propertiesWithSubCategory(propertyKey);
-        this.hasSubCategoryWithId = (propertyKey, categoryId) => this.properties[propertyKey].category?.subCategory?.id === categoryId;
-        this.properties = properties;
-    }
-    create() {
-        const categories = this.createTreeCategories();
-        const rootProperties = this.getRootProperties();
-        if (rootProperties.length) {
-            categories.push({
-                name: PropertyTreeCreator.DEFAULT_CATEGORY_NAME,
-                id: PropertyTreeCreator.DEFAULT_CATEGORY_ID,
-                subCategories: [],
-                properties: rootProperties,
-            });
-        }
-        const tree = {
-            categories,
-        };
-        return tree;
-    }
-    getRootProperties() {
-        const rootProperties = Object.keys(this.properties)
-            .filter(this.propertiesWithoutCategory)
-            .map((key) => this.properties[key])
-            .filter(this.isNonList);
-        return rootProperties;
-    }
-    createTreeCategories() {
-        const categories = this.getCategories();
-        const treeCategories = this.convertToTreeCategories(categories);
-        return treeCategories;
-    }
-    getCategories() {
-        const categories = Object.keys(this.properties)
-            .filter(this.propertiesWithCategory)
-            .map((key) => this.properties[key].category)
-            .filter(PropertyTreeCreator.distinctCategories);
-        return categories;
-    }
-    convertToTreeCategories(categories) {
-        return categories.map((category) => {
-            const properties = Object.keys(this.properties)
-                .filter((key) => this.hasCategoryWithId(key, category.id))
-                .filter(this.propertiesWithoutSubCategory)
-                .map((key) => this.properties[key])
-                .filter(this.isNonList);
-            const subCategories = this.createTreeSubCategories(category.id);
-            return {
-                id: category.id,
-                name: category.name,
-                properties,
-                subCategories,
-            };
-        });
-    }
-    createTreeSubCategories(categoryId) {
-        const subCategories = this.getSubCategoriesOfCategory(categoryId);
-        const convertedSubCategories = subCategories
-            .map((subCategory) => this.convertSubCategory(subCategory))
-            .filter((category) => category.properties.length > 0);
-        const createdSubCategories = this.createListSubCategories(categoryId);
-        const treeCategories = convertedSubCategories.concat(createdSubCategories);
-        return treeCategories;
-    }
-    getSubCategoriesOfCategory(id) {
-        const categories = Object.keys(this.properties)
-            .filter((key) => this.hasCategoryWithId(key, id))
-            .filter(this.propertiesWithSubCategory)
-            .map((key) => this.properties[key].category?.subCategory)
-            .filter(PropertyTreeCreator.distinctCategories);
-        return categories;
-    }
-    convertSubCategory(subCategory) {
-        const properties = Object.keys(this.properties)
-            .filter((key) => this.hasSubCategoryWithId(key, subCategory.id))
-            .map((key) => this.properties[key])
-            .filter(this.isNonList);
-        return {
-            id: subCategory.id,
-            name: subCategory.name,
-            properties,
-            subCategories: [],
-        };
-    }
-    createListSubCategories(categoryId) {
-        const listProperties = Object.keys(this.properties)
-            .filter((key) => this.hasCategoryWithId(key, categoryId))
-            .map((key) => this.properties[key])
-            .filter(this.isList)
-            .filter((prop) => prop.value.length > 0);
-        const createdSubCategories = listProperties.map((property, index) => ({
-            id: PropertyTreeCreator.LIST_CATEGORY_START_ID + index,
-            name: property.name,
-            properties: this.asBoolProperties(property),
-            subCategories: [],
-        }));
-        return createdSubCategories;
-    }
-    asBoolProperties(listProperty) {
-        const values = listProperty.value;
-        const boolProperties = values.map((prop) => ({
-            name: prop,
-            value: true,
-            type: 'bool',
-            unit: listProperty.unit,
-            hint: listProperty.hint,
-        }));
-        return boolProperties;
-    }
-}
-PropertyTreeCreator.distinctCategories = (category, index, self) => {
-    const firstOccuranceOfId = self.find((value) => value.id === category.id);
-    return !!firstOccuranceOfId && self.indexOf(firstOccuranceOfId) === index;
-};
-PropertyTreeCreator.DEFAULT_CATEGORY_NAME = 'Okategoriserat';
-PropertyTreeCreator.DEFAULT_CATEGORY_ID = 0;
-PropertyTreeCreator.TEXT_LIST_TYPE = 'text-list';
-PropertyTreeCreator.LIST_CATEGORY_START_ID = 100000;
-export default PropertyTreeCreator;

package/dist-src/utils/vehicle-properties/property-tree-sorter.js

@@ -1,18 +0,0 @@
-import compareCategories from './compare-categories';
-import compareBasicProperties from './compare-basic-properties';
-import compareProperties from './compare-properties';
-const sort = (tree) => {
-    tree.categories.sort(compareCategories);
-    tree.categories.forEach((category) => {
-        if (category.id === 1000) {
-            category.properties.sort(compareBasicProperties);
-        }
-        else {
-            category.properties.sort(compareProperties);
-            category.subCategories.forEach((subCategory) => {
-                subCategory.properties.sort(compareProperties);
-            });
-        }
-    });
-};
-export default sort;

package/dist-types/@types/action.d.ts

@@ -1,3 +0,0 @@
-export interface BaseAction<T> {
-    type: T;
-}