@trackunit/filters-graphql-hook 2.1.54-alpha-6a85feaada3.0 → 2.1.54

package/index.cjs.js

@@ -444,7 +444,15 @@ const useCustomFieldFilters = (filters) => {
     }, [filters]);
 };
 
+/**
+ * Prefix used for custom-field filter keys in the Manager filter-bar value map.
+ *
+ * Lives in its own dependency-free module so lightweight consumers (e.g. the
+ * lazily-loaded AssetFiltersInput converter) can reference the constant without
+ * pulling in the `useActiveAssetFilters` hook graph.
+ */
 const CustomFieldPrefix = "cf__";
+
 /**
  * Converts field filters to a format that can be used by the GraphQL API for AssetFiltersInput
  *
@@ -516,6 +524,7 @@ const useActiveAssetFilters = (filters) => {
             })(),
             fleetHealthDeviceStatuses: fixTypes(valueNameArrayOrUndefined(filters.fleetHealthStatus), fleetDataHealthDeviceStatus),
             deviceTypes: valueNameArrayOrUndefined(filters.deviceTypes),
+            firmwareVersion: valueNameArrayOrUndefined(filters.firmwareVersion),
             sustainabilityExcluded: valueBooleanOrUndefined(filters.assetVisibility),
             accessManagementDesiredModes: fixTypes(filters.accessManagementMode, accessManagementMode),
             insightsFilters: {
@@ -562,6 +571,368 @@ const useActiveAssetFilters = (filters) => {
 };
 const booleanArraySchema = zod.z.array(zod.z.boolean());
 
+const numberRangeSchema = zod.z.object({
+    min: zod.z.number().optional(),
+    max: zod.z.number().optional(),
+});
+const aggregatedNumberRangeSchema = zod.z.object({
+    period: zod.z.literal("LIFETIME"),
+    range: numberRangeSchema,
+});
+const customFieldSchema = zod.z
+    .object({
+    booleanValue: zod.z.boolean().optional(),
+    dateRange: filtersFilterBar.dateRangeSchema.optional(),
+    definitionId: zod.z.string().optional(),
+    numberRange: zod.z
+        .object({
+        from: zod.z.number().optional(),
+        to: zod.z.number().optional(),
+    })
+        .optional(),
+    stringArrayValue: zod.z.array(zod.z.string()).optional(),
+    stringWildcardValue: zod.z.string().optional(),
+})
+    .strip();
+/**
+ * Drift guard: keying the supported subset to `keyof AssetFiltersInput` forces a
+ * compile error if the generated GraphQL schema renames or removes a field we map.
+ * Enum-value drift is already caught because every `z.nativeEnum(...)` references a
+ * generated GraphQL enum, so a removed enum breaks the import.
+ */
+const assetFiltersInputSchema = zod.z
+    .object({
+    accessManagementDesiredModes: zod.z.array(zod.z.nativeEnum(accessManagementMode)).optional(),
+    activeFilter: zod.z.boolean().optional(),
+    activities: zod.z.array(zod.z.nativeEnum(assetActivityState)).optional(),
+    area: filtersFilterBar.areaFilterGeoJsonGeometrySchema.optional(),
+    assetIds: zod.z.array(zod.z.string()).optional(),
+    assetTypes: zod.z.array(zod.z.nativeEnum(assetType)).optional(),
+    brands: zod.z.array(zod.z.string()).optional(),
+    criticalities: zod.z.array(zod.z.nativeEnum(assetCriticalityState)).optional(),
+    customerIds: zod.z.array(zod.z.string()).optional(),
+    deviceTypes: zod.z.array(zod.z.string()).optional(),
+    firmwareVersion: zod.z.array(zod.z.string()).optional(),
+    fleetHealthCategories: zod.z.array(zod.z.nativeEnum(fleetDataHealthIssueCategory)).optional(),
+    fleetHealthDeviceStatuses: zod.z.array(zod.z.nativeEnum(fleetDataHealthDeviceStatus)).optional(),
+    fleetHealthTypes: zod.z.array(zod.z.nativeEnum(fleetDataHealthIssueType)).optional(),
+    groups: zod.z.array(zod.z.string()).optional(),
+    customFields: zod.z.array(customFieldSchema).optional(),
+    insightsFilters: zod.z
+        .object({
+        afterTreatmentDieselExhaustFluidTankLevel: numberRangeSchema.optional(),
+        batteryChargerState: zod.z.array(zod.z.boolean()).optional(),
+        batteryPotential: numberRangeSchema.optional(),
+        batteryStateOfChargePercent: numberRangeSchema.optional(),
+        cumulativeIdleHours: aggregatedNumberRangeSchema.optional(),
+        cumulativeOperatingHours: aggregatedNumberRangeSchema.optional(),
+        fuelLevel: numberRangeSchema.optional(),
+    })
+        .strip()
+        .optional(),
+    lastSeen: zod.z.nativeEnum(assetLastSeen).optional(),
+    metadataCompleteness: zod.z.nativeEnum(metadataCompleteness).optional(),
+    models: zod.z.array(zod.z.string()).optional(),
+    ownerAccountIds: zod.z.array(zod.z.string()).optional(),
+    owningDepotSiteIds: zod.z.array(zod.z.string()).optional(),
+    partnerId: zod.z.string().optional(),
+    pendingTelematicsDevices: zod.z.array(zod.z.string()).optional(),
+    rentalActiveContractFilters: zod.z
+        .object({
+        customerExternalReferences: zod.z.array(zod.z.string()).optional(),
+        customerParentExternalReferences: zod.z.array(zod.z.string()).optional(),
+        customerParentNames: zod.z.array(zod.z.string()).optional(),
+        offRentDatesDateRange: filtersFilterBar.dateRangeSchema.optional(),
+        onRentDatesDateRange: filtersFilterBar.dateRangeSchema.optional(),
+    })
+        .optional(),
+    rentalContractOrderNumbers: zod.z.array(zod.z.string()).optional(),
+    rentalContractReferenceCodeDescriptionQuery: zod.z.string().optional(),
+    rentalContractReferenceCodes: zod.z.array(zod.z.string()).optional(),
+    rentalStatuses: zod.z.array(zod.z.nativeEnum(rentalStatus)).optional(),
+    searchQuery: zod.z.string().optional(),
+    serviceBooked: zod.z.array(zod.z.boolean()).optional(),
+    servicePlanAssignments: zod.z.array(zod.z.nativeEnum(servicePlanStatus)).optional(),
+    servicePlanIds: zod.z.array(zod.z.string()).optional(),
+    servicePlanStatuses: zod.z.array(zod.z.nativeEnum(servicePlanStatus)).optional(),
+    serviceProviderIds: zod.z.array(zod.z.string()).optional(),
+    siteIds: zod.z.array(zod.z.string()).optional(),
+    siteTypes: zod.z.array(zod.z.nativeEnum(siteTypeSFS)).optional(),
+    sustainabilityExcluded: zod.z.boolean().optional(),
+    telematicsDeviceIsConnected: zod.z.boolean().optional(),
+    types: zod.z.array(zod.z.string()).optional(),
+})
+    .strip();
+/**
+ * Type guard for plain (non-array) objects so unknown payloads can be traversed safely.
+ *
+ * @param value - Unknown value to test.
+ * @returns {boolean} True when the value is a non-null, non-array object.
+ */
+const isPlainObject = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+/**
+ * Recursively strips properties whose value is `null` so they are treated as omitted.
+ *
+ * The generated `AssetFiltersInput` uses InputMaybe (`T | null | undefined`), and
+ * `useActiveAssetFilters` emits `null` for unset fields. The zod schema rejects `null`,
+ * so this deep-strips `null`-valued properties from plain objects, recursing into nested
+ * plain objects and arrays of plain objects. Non-null values are returned unchanged.
+ *
+ * @param value - Unknown payload to normalize.
+ * @returns {unknown} The payload with all `null`-valued properties removed.
+ */
+const stripNullProperties = (value) => {
+    if (Array.isArray(value)) {
+        return value.map(stripNullProperties);
+    }
+    if (isPlainObject(value)) {
+        const result = {};
+        for (const [key, propertyValue] of Object.entries(value)) {
+            if (propertyValue === null) {
+                continue;
+            }
+            result[key] = stripNullProperties(propertyValue);
+        }
+        return result;
+    }
+    return value;
+};
+/**
+ * Validates an unknown payload against the supported public GraphQL AssetFiltersInput subset.
+ *
+ * Unknown/unsupported keys are stripped; invalid values for supported fields produce an error.
+ *
+ * @param input - Unknown hash payload supplied to /goto/assets or /goto/map.
+ * @returns {ParseAssetFiltersInputResult} The stripped, validated subset or a validation error.
+ */
+const parseAssetFiltersInput = (input) => {
+    const parsed = assetFiltersInputSchema.safeParse(stripNullProperties(input));
+    if (!parsed.success) {
+        return { success: false, error: parsed.error.message };
+    }
+    return { success: true, data: parsed.data };
+};
+
+/**
+ * Map plain strings to ValueName objects (inverse of valueNameArrayOrUndefined).
+ */
+const toValueNameArray = (values) => {
+    return values.map(value => ({ name: value, value }));
+};
+/**
+ * Wrap a boolean in a boolean filter value (inverse of valueBooleanOrUndefined).
+ */
+const toBooleanFilterValue = (booleanValue) => {
+    return { booleanValue };
+};
+/**
+ * Map a number range to a min/max filter value (inverse of minMaxFilterValueToNumberRange).
+ */
+const toMinMaxFilterValue = (range) => {
+    return { min: range.min, max: range.max };
+};
+/**
+ * Converts a public GraphQL AssetFiltersInput-shaped object to Manager filter-bar values.
+ *
+ * @param input - Unknown hash payload supplied to /goto/assets or /goto/map.
+ * @returns {AssetFiltersInputToFilterBarValuesResult} A conversion result with stripped unsupported fields or validation errors for invalid supported fields.
+ */
+const convertAssetFiltersInputToFilterBarValues = (input) => {
+    const parsed = parseAssetFiltersInput(input);
+    if (!parsed.success) {
+        return { success: false, error: parsed.error };
+    }
+    const filterBarValues = {};
+    if (parsed.data.searchQuery !== undefined) {
+        filterBarValues.search = parsed.data.searchQuery;
+    }
+    if (parsed.data.assetIds !== undefined) {
+        filterBarValues.assetIds = parsed.data.assetIds;
+    }
+    if (parsed.data.siteIds !== undefined) {
+        filterBarValues.siteIds = toValueNameArray(parsed.data.siteIds);
+    }
+    if (parsed.data.groups !== undefined) {
+        filterBarValues.groups = toValueNameArray(parsed.data.groups);
+    }
+    if (parsed.data.ownerAccountIds !== undefined) {
+        filterBarValues.ownerAccountIds = toValueNameArray(parsed.data.ownerAccountIds);
+    }
+    if (parsed.data.customerIds !== undefined) {
+        filterBarValues.customerIds = toValueNameArray(parsed.data.customerIds);
+    }
+    if (parsed.data.owningDepotSiteIds !== undefined) {
+        filterBarValues.siteDepotOwnershipIds = toValueNameArray(parsed.data.owningDepotSiteIds);
+    }
+    if (parsed.data.brands !== undefined) {
+        filterBarValues.brands = parsed.data.brands;
+    }
+    if (parsed.data.types !== undefined) {
+        filterBarValues.types = parsed.data.types;
+    }
+    if (parsed.data.models !== undefined) {
+        filterBarValues.models = parsed.data.models;
+    }
+    if (parsed.data.pendingTelematicsDevices !== undefined) {
+        filterBarValues.pendingTelematicsDevices = parsed.data.pendingTelematicsDevices;
+    }
+    if (parsed.data.deviceTypes !== undefined) {
+        filterBarValues.deviceTypes = toValueNameArray(parsed.data.deviceTypes);
+    }
+    if (parsed.data.firmwareVersion !== undefined) {
+        filterBarValues.firmwareVersion = toValueNameArray(parsed.data.firmwareVersion);
+    }
+    if (parsed.data.activities !== undefined) {
+        filterBarValues.activity = parsed.data.activities;
+    }
+    if (parsed.data.assetTypes !== undefined) {
+        filterBarValues.assetType = parsed.data.assetTypes;
+    }
+    if (parsed.data.criticalities !== undefined) {
+        filterBarValues.criticality = parsed.data.criticalities;
+    }
+    if (parsed.data.rentalStatuses !== undefined) {
+        filterBarValues.rentalStatuses = parsed.data.rentalStatuses;
+    }
+    if (parsed.data.siteTypes !== undefined) {
+        filterBarValues.siteType = parsed.data.siteTypes;
+    }
+    if (parsed.data.fleetHealthTypes !== undefined) {
+        filterBarValues.fleetHealthTypes = toValueNameArray(parsed.data.fleetHealthTypes);
+    }
+    if (parsed.data.fleetHealthCategories !== undefined) {
+        filterBarValues.fleetHealthCategories = toValueNameArray(parsed.data.fleetHealthCategories);
+    }
+    if (parsed.data.fleetHealthDeviceStatuses !== undefined) {
+        filterBarValues.fleetHealthStatus = toValueNameArray(parsed.data.fleetHealthDeviceStatuses);
+    }
+    if (parsed.data.accessManagementDesiredModes !== undefined) {
+        filterBarValues.accessManagementMode = parsed.data.accessManagementDesiredModes;
+    }
+    if (parsed.data.activeFilter !== undefined) {
+        filterBarValues.activeFilter = toBooleanFilterValue(parsed.data.activeFilter);
+    }
+    if (parsed.data.telematicsDeviceIsConnected !== undefined) {
+        filterBarValues.telematicsConnected = toBooleanFilterValue(parsed.data.telematicsDeviceIsConnected);
+    }
+    if (parsed.data.sustainabilityExcluded !== undefined) {
+        filterBarValues.assetVisibility = toBooleanFilterValue(parsed.data.sustainabilityExcluded);
+    }
+    if (parsed.data.area !== undefined) {
+        filterBarValues.area = parsed.data.area;
+    }
+    if (parsed.data.lastSeen !== undefined) {
+        filterBarValues.lastSeen = parsed.data.lastSeen;
+    }
+    if (parsed.data.metadataCompleteness !== undefined) {
+        filterBarValues.metadataCompleteness = { name: parsed.data.metadataCompleteness, value: parsed.data.metadataCompleteness };
+    }
+    if (parsed.data.serviceBooked !== undefined) {
+        filterBarValues.serviceBooked = parsed.data.serviceBooked;
+    }
+    if (parsed.data.servicePlanAssignments !== undefined) {
+        filterBarValues.servicePlanStatus = parsed.data.servicePlanAssignments;
+    }
+    if (parsed.data.servicePlanIds !== undefined) {
+        filterBarValues.servicePlan = toValueNameArray(parsed.data.servicePlanIds);
+    }
+    if (parsed.data.servicePlanStatuses !== undefined) {
+        filterBarValues.serviceStatus = parsed.data.servicePlanStatuses;
+    }
+    if (parsed.data.serviceProviderIds !== undefined) {
+        filterBarValues.serviceProvider = toValueNameArray(parsed.data.serviceProviderIds);
+    }
+    if (parsed.data.partnerId !== undefined) {
+        filterBarValues.partner = toValueNameArray([parsed.data.partnerId]);
+    }
+    if (parsed.data.rentalContractOrderNumbers !== undefined) {
+        filterBarValues.rentalContractOrderNumber = parsed.data.rentalContractOrderNumbers;
+    }
+    if (parsed.data.rentalContractReferenceCodes !== undefined) {
+        filterBarValues.rentalContractReferenceCode = parsed.data.rentalContractReferenceCodes;
+    }
+    if (parsed.data.rentalContractReferenceCodeDescriptionQuery !== undefined) {
+        filterBarValues.rentalContractReferenceCodeDescriptionQuery =
+            parsed.data.rentalContractReferenceCodeDescriptionQuery;
+    }
+    if (parsed.data.rentalActiveContractFilters?.onRentDatesDateRange !== undefined) {
+        filterBarValues.rentalActiveContractItemOnRentDatesDateRange =
+            parsed.data.rentalActiveContractFilters.onRentDatesDateRange;
+    }
+    if (parsed.data.rentalActiveContractFilters?.offRentDatesDateRange !== undefined) {
+        filterBarValues.rentalActiveContractItemOffRentDatesDateRange =
+            parsed.data.rentalActiveContractFilters.offRentDatesDateRange;
+    }
+    if (parsed.data.rentalActiveContractFilters?.customerExternalReferences !== undefined) {
+        filterBarValues.rentalContractCustomerExternalReference =
+            parsed.data.rentalActiveContractFilters.customerExternalReferences;
+    }
+    if (parsed.data.rentalActiveContractFilters?.customerParentExternalReferences !== undefined) {
+        filterBarValues.rentalContractCustomerParentExternalReference =
+            parsed.data.rentalActiveContractFilters.customerParentExternalReferences;
+    }
+    if (parsed.data.rentalActiveContractFilters?.customerParentNames !== undefined) {
+        filterBarValues.rentalContractCustomerParentName = parsed.data.rentalActiveContractFilters.customerParentNames;
+    }
+    if (parsed.data.insightsFilters?.fuelLevel !== undefined) {
+        filterBarValues.insightsFuelLevel = toMinMaxFilterValue(parsed.data.insightsFilters.fuelLevel);
+    }
+    if (parsed.data.insightsFilters?.afterTreatmentDieselExhaustFluidTankLevel !== undefined) {
+        filterBarValues.insightsAfterTreatmentDieselExhaustFluidTankLevel = toMinMaxFilterValue(parsed.data.insightsFilters.afterTreatmentDieselExhaustFluidTankLevel);
+    }
+    if (parsed.data.insightsFilters?.batteryPotential !== undefined) {
+        filterBarValues.insightsBatteryPotential = toMinMaxFilterValue(parsed.data.insightsFilters.batteryPotential);
+    }
+    if (parsed.data.insightsFilters?.batteryStateOfChargePercent !== undefined) {
+        filterBarValues.insightsBatteryStateOfChargePercent = toMinMaxFilterValue(parsed.data.insightsFilters.batteryStateOfChargePercent);
+    }
+    if (parsed.data.insightsFilters?.cumulativeIdleHours !== undefined) {
+        filterBarValues.insightsCumulativeIdleHours = toMinMaxFilterValue(parsed.data.insightsFilters.cumulativeIdleHours.range);
+    }
+    if (parsed.data.insightsFilters?.cumulativeOperatingHours !== undefined) {
+        filterBarValues.insightsCumulativeOperatingHours = toMinMaxFilterValue(parsed.data.insightsFilters.cumulativeOperatingHours.range);
+    }
+    if (parsed.data.insightsFilters?.batteryChargerState?.[0] !== undefined) {
+        const value = String(parsed.data.insightsFilters.batteryChargerState[0]);
+        filterBarValues.insightsBatteryChargerState = { name: value, value };
+    }
+    parsed.data.customFields?.forEach(customField => {
+        if (!customField.definitionId) {
+            return;
+        }
+        const key = `${CustomFieldPrefix}${customField.definitionId}`;
+        if (customField.stringWildcardValue !== undefined) {
+            filterBarValues[key] = customField.stringWildcardValue;
+        }
+        else if (customField.stringArrayValue !== undefined) {
+            filterBarValues[key] = customField.stringArrayValue;
+        }
+        else if (customField.numberRange !== undefined) {
+            filterBarValues[key] = { min: customField.numberRange.from, max: customField.numberRange.to };
+        }
+        else if (customField.dateRange !== undefined) {
+            filterBarValues[key] = customField.dateRange;
+        }
+        else if (customField.booleanValue !== undefined) {
+            filterBarValues[key] = toBooleanFilterValue(customField.booleanValue);
+        }
+    });
+    return { success: true, filterBarValues };
+};
+
+/**
+ * Exposes the AssetFiltersInput converter through a stable hook API.
+ *
+ * @returns {{ assetFiltersInputToFilterBarValues: (input: unknown) => AssetFiltersInputToFilterBarValuesResult }} Stable converter API.
+ */
+const useAssetFiltersInputToFilterBarValues = () => {
+    return react.useMemo(() => ({
+        assetFiltersInputToFilterBarValues: convertAssetFiltersInputToFilterBarValues,
+    }), []);
+};
+
 /**
  * Sort properties that require an aggregation period
  */
@@ -645,6 +1016,7 @@ exports.minMaxFilterValueToNumberRange = minMaxFilterValueToNumberRange;
 exports.positiveValueBooleanOrNull = positiveValueBooleanOrNull;
 exports.stringArrayOrUndefined = stringArrayOrUndefined;
 exports.useActiveAssetFilters = useActiveAssetFilters;
+exports.useAssetFiltersInputToFilterBarValues = useAssetFiltersInputToFilterBarValues;
 exports.useAssetQueryFilters = useAssetQueryFilters;
 exports.useAssetSortInput = useAssetSortInput;
 exports.useCustomFieldFilters = useCustomFieldFilters;