@trackunit/shared-utils 0.0.3-alpha-bfdefa6ec9.0

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@trackunit/shared-utils",
+  "version": "0.0.3-alpha-bfdefa6ec9.0",
+  "repository": "https://github.com/Trackunit/manager",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "engines": {
+    "node": ">=18.x"
+  },
+  "dependencies": {
+    "@sentry/react": "7.57.0",
+    "crossfilter2": "1.5.4",
+    "moment": "2.29.4"
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "peerDependencies": {}
+}

package/src/DateTimeFormat.d.ts

@@ -0,0 +1,19 @@
+export declare enum HoursAndMinutesFormat {
+    HOURS_MIN_SEC_LONG = "HOURS_MIN_SEC_LONG",
+    HOURS_MIN_SEC = "HOURS_MIN_SEC",
+    HOURS_MIN_LONG = "HOURS_MIN_LONG",
+    HOURS_MIN = "HOURS_MIN",
+    HOURS_LONG = "HOURS_LONG"
+}
+export declare enum DateTimeFormat {
+    DATE = "L",
+    DATE_LONG = "LL",
+    DATE_LONG_TIME = "LLL",
+    DATE_SHORT = "ll",
+    DATE_SHORT_TIME = "lll",
+    TIME_SHORT = "LT",
+    TIME_LONG = "LTS",
+    YEAR = "YYYY",
+    YEAR_MONTH_DAY = "yyyy-MM-DD",
+    MONTH_DAY = "MMM, Do"
+}

package/src/DateUtils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @description Converts a date to a string in ISO format.
+ * @param date  A date object or a date string.
+ * @returns {string | null} A string in ISO format or null if the input is invalid.
+ * @example getISOStringFromDate(new Date("2021-05-19T12:34:56")) // "2021-05-19T12:34:56.000Z"
+ */
+export declare const getISOStringFromDate: (date: Date | string | undefined | null) => string | null;
+/**
+ * @description Returns the difference between two dates in the specified unit.
+ * @param date1 The first date.
+ * @param date2 The second date.
+ * @param unit The unit to return the difference in.
+ * @returns {number} The difference between the two dates in the specified unit.
+ */
+export declare const getDifferenceBetweenDates: (date1: Date, date2: Date, unit: "days" | "hours" | "minutes" | "seconds") => number;
+/**
+ * @description Returns the start of the day for a given date.
+ * @param date A date object or a date string.
+ * @returns {Date} The start of the day for the given date.
+ * @example getStartOfDay(new Date("2021-05-19T12:34:56")) // "2021-05-19T00:00:00"
+ */
+export declare const getStartOfDay: <T extends string | number | Date>(date: T) => Date;
+/**
+ * @description Returns the end of the day for a given date.
+ * @param date A date object or a date string.
+ * @returns {Date} The end of the day for the given date.
+ * @example getEndOfDay(new Date("2021-05-19T12:34:56")) // "2021-05-19T23:59:59"
+ */
+export declare const getEndOfDay: <T extends string | number | Date>(date: T) => Date;

package/src/GeoJsonUtils.d.ts

@@ -0,0 +1,26 @@
+interface PointCoordinate {
+    longitude: number;
+    latitude: number;
+}
+interface GeoJSONGeometry {
+    type?: unknown;
+    coordinates?: number[] | number[][] | null;
+}
+interface GeoJsonFeature {
+    type?: unknown;
+    geometry?: GeoJSONGeometry | null;
+}
+/**
+ * @description Extracts a point coordinate from a GeoJSON object.
+ * @param geoObject A GeoJSON object.
+ * @returns {PointCoordinate} A point coordinate.
+ */
+export declare const getPointCoordinateFromGeoJsonObject: (geoObject: GeoJsonFeature | GeoJSONGeometry | undefined | null) => PointCoordinate | undefined;
+/**
+ * @description Extracts multiple point coordinates from a GeoJSON object.
+ * @param geoObject A GeoJSON object.
+ * @returns {PointCoordinate[]} An array of point coordinates.
+ * @example getMultipleCoordinatesFromGeoJsonObject({ type: "Point", coordinates: [1, 2] }) // [{ longitude: 1, latitude: 2 }]
+ */
+export declare const getMultipleCoordinatesFromGeoJsonObject: (geoObject: GeoJsonFeature | GeoJSONGeometry | undefined | null) => PointCoordinate[] | undefined;
+export {};

package/src/TimePeriod.d.ts

@@ -0,0 +1,12 @@
+export declare enum TimePeriod {
+    THIS_WEEK = "THIS_WEEK",
+    LAST_WEEK = "LAST_WEEK",
+    THIS_MONTH = "THIS_MONTH",
+    LAST_MONTH = "LAST_MONTH"
+}
+export declare enum DayPeriod {
+    LAST_24_HOURS = "LAST_24_HOURS",
+    LAST_7_DAYS = "LAST_7_DAYS",
+    LAST_30_DAYS = "LAST_30_DAYS",
+    LIFETIME = "LIFETIME"
+}

package/src/UnitOfMeasurementConverter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Converts meters to yards
+ *
+ * @param value The value to convert
+ * @returns {number | undefined} The converted value
+ */
+export declare const convertMetersToYards: (value: number) => number | undefined;
+/**
+ * Converts yards to meters
+ *
+ * @param value The value to convert
+ * @returns {number | undefined} The converted value
+ */
+export declare const convertYardsToMeters: (value: number) => number | undefined;

package/src/addressUtils.d.ts

@@ -0,0 +1,32 @@
+interface Address {
+    /** The city of the address. */
+    city?: string | null;
+    /** The country of the address. */
+    country?: string | null;
+    /** The street address. */
+    streetAddress?: string | null;
+    /** The zip code or postal code of the address. */
+    zipCode?: string | null;
+}
+interface Coordinates {
+    /** The latitude of the coordinate. */
+    latitude: number;
+    /** The longitude of the coordinate. */
+    longitude: number;
+}
+/**
+ * @description Formats an address into a single string.
+ * @param address The address to format.
+ * @returns {string} The formatted address.
+ * @example formatAddress({ streetAddress: "Street 1", zipCode: "12345", city: "City", country: "Country" }) // "Street 1, 12345 City, Country"
+ */
+export declare const formatAddress: (address: Address | null | undefined) => string | null;
+/**
+ * @description Formats coordinates into a single string.
+ * @param coordinates The coordinates to format.
+ * @param toFixed The number of digits to appear after the decimal point.
+ * @returns {string} The formatted coordinates.
+ * @example formatCoordinates({ latitude: 1.234567, longitude: 2.345678 }) // "1.234567, 2.345678"
+ */
+export declare const formatCoordinates: (coordinates: Coordinates, toFixed?: number) => string;
+export {};

package/src/arrayUtils.d.ts

@@ -0,0 +1,24 @@
+/** toggle whether a value is in an array or not */
+export declare function toggle<T>(array: T[] | null | undefined, value: T | null | undefined): T[];
+/** Ensure the argument is an array, if not, create array with that element in it */
+export declare function ensureArray<T>(arrayish: T | T[]): T[];
+/**
+ * Returns the first item in an array, and logs a warning if there are more than one item in the array.
+ *
+ * @param array The array to get the first item from
+ * @param location The location from where this function is called
+ * @returns The first item in the array
+ * @example getFirstItemAndLogIfMore([1, 2, 3], "getFirstItemAndLogIfMore") // 1
+ */
+export declare const getFirstItemAndLogIfMore: <T>(array?: T[] | null | undefined, location?: string) => T | undefined;
+/**
+ * Returns a new array with the items from the previous array and the new array, but only if the item's key is unique.
+ *
+ * @param key   The key to use to determine uniqueness
+ * @param previous The previous array of items to merge with the new array
+ * @param newArray The new array of items to merge with the previous array
+ * @returns A new array with the items from the previous array and the new array, but only if the item's key is unique.
+ */
+export declare const unionArraysByKey: <T extends object>(key: keyof T, previous: T[] | null | undefined, newArray: T[] | null | undefined) => T[];
+/** Ensures if an array is equal to another array */
+export declare const isStringArrayEqual: (first?: string[], second?: string[]) => boolean;

package/src/chameleonUtils.d.ts

@@ -0,0 +1,4 @@
+export interface IChameleonAware {
+    /** Hardcode an anchor to be used by chameleon */
+    chameleonId?: string;
+}

package/src/constants/align.d.ts

@@ -0,0 +1,6 @@
+export declare const align: {
+    LEFT: "left";
+    CENTER: "center";
+    RIGHT: "right";
+};
+export type Align = typeof align[keyof typeof align];

package/src/constants/hourIntervals.d.ts

@@ -0,0 +1 @@
+export declare const hourIntervals: readonly ["0", "0–2", "2–4", "4–6", "6–8", "8–10", "10–12", "12–14", "14–16", "16–18", "18–20", "20–22", "22–24"];

package/src/constants/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./align";
+export * from "./hourIntervals";
+export * from "./size";

package/src/constants/size.d.ts

@@ -0,0 +1,6 @@
+export declare const size: {
+    SMALL: "small";
+    MEDIUM: "medium";
+    LARGE: "large";
+};
+export type Size = typeof size[keyof typeof size];

package/src/dimensionHelpers.d.ts

@@ -0,0 +1,11 @@
+import crossfilter from "crossfilter2";
+/**
+ * Gets the filtered record values where the value is over 0
+ *
+ * @param dimension the record dimension
+ */
+export declare const getDimensionValues: <RecordType, TValue extends crossfilter.NaturallyOrderedValue>(dimension: crossfilter.Dimension<RecordType, TValue>) => crossfilter.Grouping<crossfilter.NaturallyOrderedValue, crossfilter.NaturallyOrderedValue>[];
+/**
+ * This value is used to group null or undefined values
+ */
+export declare const UNKNOWN_VALUE = "Unknown";

package/src/doNothing.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Do nothing usefull for creating mocks without dependency on jest or anything else.
+ */
+export declare function doNothing(): void;

package/src/enumUtils.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Returns the enum value from a string value.
+ *
+ * @param val The string value to convert to an enum value.
+ * @param _enum The enum to convert the string value to.
+ * @returns {Record<string, string>} The enum value.
+ * @example enumFromValue("MACHINE", AssetType) // AssetType.MACHINE
+ */
+export declare const enumFromValue: <T extends Record<string, string>>(val: string, _enum: T) => T[keyof T];
+/**
+ * Returns the enum value from a string value or undefined if the string value is undefined or null.
+ *
+ * @param _enum The enum to convert the string value to.
+ * @param val The string value to convert to an enum value.
+ * @returns {Record<string, string> | undefined} The enum value or undefined.
+ * @example enumFromValue("MACHINE", AssetType) // AssetType.MACHINE
+ */
+export declare const enumOrUndefinedFromValue: <T extends Record<string, string>>(_enum: T, val?: string | null) => T[keyof T] | undefined;
+/**
+ * Returns the enum value from a string value or undefined if the string value is undefined or null.
+ * This is a typesafe version of enumOrUndefinedFromValue.
+ *
+ * @param val The string value to convert to an enum value.
+ * @param _enum The enum to convert the string value to.
+ * @returns {Record<string, string> | undefined} The enum value or undefined.
+ * @example enumFromValue("MACHINE", AssetType) // AssetType.MACHINE
+ */
+export declare const enumFromValueTypesafe: <T extends Record<string, string>>(val: keyof T, _enum: T) => T[keyof T];

package/src/exhaustiveCheck.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A function that will throw an error if it is called with a value that is not of type `never`.
+ * This is useful for exhaustiveness checks in switch statements.
+ *
+ * @example
+ * const type: "foo" | "bar" | "other" =
+ * switch (type) {
+ *  case "foo": return foo();
+ *  case "bar": return bar();
+ *  default: return exhaustiveCheck(type); // Will show a TS error as "other" is not of type "never"
+ * }
+ * @param value The value you want to check exhaustively
+ */
+export declare const exhaustiveCheck: (value: never) => never;

package/src/fastArrayOperations.d.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * @param arr1 An array of string or numbers
+ * @param arr2 An array of string or numbers
+ * @returns The elements shared between arr1 and arr2.
+ */
+export declare function intersection<T>(arr1: T[], arr2: T[]): T[];
+/**
+ *
+ * @param arr1 An array of string or numbers
+ * @param arr2 An array of string or numbers
+ * @returns The elements present in arr1 but not arr2.
+ */
+export declare function difference<T>(arr1: T[], arr2: T[]): T[];

package/src/filter.d.ts

@@ -0,0 +1,25 @@
+import { Maybe } from "./maybe";
+/**
+ * Filter an array of items based on a list of properties and a search term.
+ * The provided properties will be matched based on the term split on space.
+ * All terms must have at least one match
+ * The terms can match the same property multiple times
+ *
+ * @param array The array to filter
+ * @param props The properties to filter by
+ * @param match The string to match against
+ * @returns {[]} The filtered array
+ * @example filterByMultiple([{ name: "John", surname: "Doe" }, { name: "Jane", surname: "Doe" }], [p => p.name, p => p.surname], "John") // [{ name: "John", surname: "Doe" }]
+ */
+export declare function filterByMultiple<T>(array: T[] | null | undefined, props: (p: T) => Maybe<string>[] | null | undefined, match: string): T[];
+/**
+ * Filter an array of items based on a list of properties and a search term.
+ * The provided properties will be matched based on the term split on space.
+ * All terms must have at least one match
+ * The terms can match the same property multiple times
+ */
+export declare const fuzzySearch: <T>(elementsToFilter: T[], filterableProps: (element: T) => string[], searchTerm: string) => T[];
+/**
+ * Filter an array of items based on a search term.
+ */
+export declare const Search: <T>(elementsToSearch: T[], searchableProps: (element: T) => string[], searchTerm: string) => T[];

package/src/groupBy/groupBy.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Group an array of items by a key.
+ *
+ * @param list The array of items to group.
+ * @param getKey A function to get the key to group by.
+ * @returns A map of the items grouped by the key.
+ * @example groupBy([{ name: "John", surname: "Doe" }, { name: "Jane", surname: "Doe" }], p => p.surname) // Map { "Doe" => [{ name: "John", surname: "Doe" }, { name: "Jane", surname: "Doe" }] }
+ */
+export declare function groupBy<T, K>(list: T[], getKey: (item: T) => K): Map<K, T[]>;

package/src/idUtils.d.ts

@@ -0,0 +1,26 @@
+/**
+ * A utility function to test whether a string is a valid UUID or not.
+ *
+ * @param input A string.
+ */
+export declare const isUUID: (input: string) => boolean;
+/**
+ * A helper function that converts any value into a UUID.
+ *
+ * @param value The value that will be converted into a UUID.
+ */
+export declare const toUUID: (value: string | number) => string;
+/**
+ * A helper function that converts a UUID to a valid machine ID.
+ *
+ * @param uuid The UUID that should be converted to a valid machine ID
+ * @returns {number} The converted machine ID
+ */
+export declare const toID: (uuid: string) => number;
+/**
+ * A helper function that converts a list of UUID to a list of valid machine IDs.
+ * NOTE that NaN will be removed so list cannot be expected to be of same size.
+ *
+ * @param uuid The list of UUIDs that should be converted to a list of valid machine IDs
+ */
+export declare const toIDs: (ids: string[] | null | undefined) => number[];

package/src/index.d.ts

@@ -0,0 +1,25 @@
+export * from "./DateTimeFormat";
+export * from "./DateUtils";
+export * from "./GeoJsonUtils";
+export * from "./TimePeriod";
+export * from "./UnitOfMeasurementConverter";
+export * from "./addressUtils";
+export * from "./arrayUtils";
+export * from "./chameleonUtils";
+export * from "./constants";
+export * from "./dimensionHelpers";
+export * from "./doNothing";
+export * from "./enumUtils";
+export * from "./exhaustiveCheck";
+export * from "./fastArrayOperations";
+export * from "./filter";
+export * from "./groupBy/groupBy";
+export * from "./idUtils";
+export * from "./maybe";
+export * from "./objectUtils";
+export * from "./pathUtils";
+export * from "./pictureUtils/pictureUtils";
+export * from "./sorting/sorting";
+export * from "./stringUtils";
+export * from "./timePeriodConverter/timePeriodConverter";
+export * from "./typeUtils";

package/src/maybe.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Maybe type
+ */
+export type Maybe<T> = T | null | undefined;

package/src/objectUtils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Deletes all undefined keys from an object.
+ *
+ * @param obj The object to delete undefined keys from.
+ * @returns The object without undefined keys.
+ * @example deleteUndefinedKeys({ a: 1, b: undefined }) // { a: 1 }
+ */
+export declare const deleteUndefinedKeys: <T extends Record<string, unknown>>(obj: T) => T;

package/src/pathUtils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @param path the path to manipulate
+ * @param apiHost the api host to remove from the path
+ * @returns {string} the updated path or empty string if null or undefined is passed in
+ * @example trimPath("https://api.example.com/api/v1/asset/123") // "asset/<...>"
+ * @example trimPath("https://api.example.com/api/v1/asset/123?test=true") // "asset/<...>"
+ * @example trimPath("https://api.example.com/api/v1/asset/123?test=true", "https://api.example.com/api/v1") // "asset/<...>"
+ * @example trimPath("https://api.example.com/api/v1/asset/123?test=true", "https://api.example.com/api/v1/") // "asset/<...>"
+ */
+export declare const trimPath: (path: string, apiHost?: string) => string;
+/**
+ * Removes UUIDs and numbers from a string and replaces them with <...>
+ *
+ * @param str the string to manipulate and remove UUIDs and replace with <...> also if path with number like asset/123/gnyf will return asset/<...>/gnyf
+ * @returns {string } the updated string or empty string if null or undefined is passed in
+ * @example trimIds("asset/123") // "asset/<...>"
+ */
+export declare const trimIds: (str: string | null | undefined) => string;

package/src/pictureUtils/pictureUtils.d.ts

@@ -0,0 +1,42 @@
+interface IResizeImageOptions {
+    maxSize: number;
+    file: File;
+}
+/**
+ * Resize a blob to be no larger than the max parameters, while maintaining the aspect ratio
+ *
+ * @param blob The blob to resize
+ * @param newWidth The max width of the resized blob
+ * @param newHeight The max height of the resized blob
+ * @returns {Promise<Blob>} A promise that resolves to the resized blob
+ * @example resizeBlob(blob, 100, 100).then(resizedBlob => { ... })
+ */
+export declare const resizeBlob: (blob: Blob, newWidth: number, newHeight: number) => Promise<Blob>;
+/**
+ * Resize width and height to be contained within the max parameters, while maintaining the aspect ratio
+ */
+export declare const getResizedDimensions: (width: number, height: number, maxWidth: number, maxHeight: number) => {
+    width: number;
+    height: number;
+};
+/**
+ * Resize an image to be no larger than the maxSize on each dimension
+ */
+export declare const resizeImage: (settings: IResizeImageOptions) => Promise<Blob>;
+/**
+ * Convert a blob to a base64 string
+ *
+ * @param blob The blob to convert
+ * @returns {Promise<string>} A promise that resolves to the base64 string
+ * @example convertBlobToBase64(blob).then(base64 => { ... })
+ */
+export declare const convertBlobToBase64: (blob: Blob) => Promise<string>;
+/**
+ * Check if the given file is a valid image format
+ *
+ * @param file The file to check
+ * @returns {boolean} True if the file is a valid image format
+ * @example isValidImage(file) // true
+ */
+export declare const isValidImage: (file: File) => boolean;
+export {};

package/src/sorting/sorting.d.ts

@@ -0,0 +1,84 @@
+import { Maybe } from "../maybe";
+/**
+ * Compare two strings
+ *
+ * @param a First string
+ * @param b Second string
+ * @returns {number} 0 if equal, -1 if a < b, 1 if a > b
+ * @example stringCompare("a", "b") // -1
+ */
+export declare const stringCompare: (a: Maybe<string>, b: Maybe<string>) => number;
+/**
+ * Compare two strings
+ *
+ * @param a First string
+ * @param b Second string
+ * @returns {number} 0 if equal, -1 if a < b, 1 if a > b
+ * @example stringCompare("a", "b") // -1
+ */
+export declare const stringNaturalCompare: (a: Maybe<string>, b: Maybe<string>) => number;
+/**
+ * Compare two strings
+ *
+ * @param key The key of the object to compare
+ * @example stringCompareFromKey("a", "b") // -1
+ * @returns {number} 0 if equal, -1 if a < b, 1 if a > b
+ * @example stringCompare("a", "b") // -1
+ * @example stringCompareFromKey("a", "b") // -1
+ */
+export declare const stringCompareFromKey: <T>(key: keyof T) => (a: T, b: T) => number;
+/**
+ * Compare two dates
+ *
+ * @param a First date
+ * @param b Second date
+ * @returns {number} 0 if equal, -1 if a < b, 1 if a > b
+ * @example dateCompare(new Date("2021-05-19T12:34:56"), new Date("2021-05-19T12:34:57")) // -1
+ * @example dateCompare(new Date("2021-05-19T12:34:56"), new Date("2021-05-19T12:34:56")) // 0
+ * @example dateCompare(new Date("2021-05-19T12:34:57"), new Date("2021-05-19T12:34:56")) // 1
+ */
+export declare const dateCompare: (a: Maybe<Date>, b: Maybe<Date>) => number;
+/**
+ * Compare two numbers
+ *
+ * @param a First number
+ * @param b Second number
+ * @returns {number} 0 if equal, -1 if a < b, 1 if a > b
+ * @example numberCompare(1, 2) // -1
+ * @example numberCompare(1, 1) // 0
+ * @example numberCompare(2, 1) // 1
+ */
+export declare const numberCompare: (a: Maybe<number>, b: Maybe<number>) => number;
+/**
+ * Compare two numbers
+ *
+ * @param a First number
+ * @param b Second number
+ * @returns {number} 0 if equal, -1 if a < b, 1 if a > b
+ * @example numberCompare(1, 2) // -1
+ * @example numberCompare(1, 1) // 0
+ * @example numberCompare(2, 1) // 1
+ */
+export declare const numberCompareUnknownAfterHighest: (a: Maybe<number>, b: Maybe<number>) => number;
+/**
+ * Compare two arrays
+ *
+ * @param a First array
+ * @param b Second array
+ * @returns {number} 0 if equal, -1 if a < b, 1 if a > b
+ * @example arrayCompare([1, 2], [1, 3], numberCompare) // -1
+ * @example arrayCompare([1, 2], [1, 2], numberCompare) // 0
+ * @example arrayCompare([1, 3], [1, 2], numberCompare) // 1
+ */
+export declare const arrayLengthCompare: <T>(a: Maybe<T[]>, b: Maybe<T[]>) => number;
+/**
+ * Compare two booleans
+ *
+ * @param a First boolean
+ * @param b Second boolean
+ * @returns {number} 0 if equal, -1 if a < b, 1 if a > b
+ * @example booleanCompare(true, false) // -1
+ * @example booleanCompare(true, true) // 0
+ * @example booleanCompare(false, true) // 1
+ */
+export declare const booleanCompare: (a: Maybe<boolean>, b: Maybe<boolean>) => number;

package/src/stringUtils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Capitalizes the first letter of a string
+ *
+ * @param s The string to capitalize
+ * @returns {string} The capitalized string
+ * @example capitalize("test") // "Test"
+ * @example capitalize("Test") // "Test"
+ * @example capitalize("test test") // "Test test"
+ * @example capitalize("test-test") // "Test-test"
+ */
+export declare const capitalize: (s: string | null | undefined) => string;
+/**
+ * Capitalizes the first letter. All other letters are converted to lowercase.
+ *
+ * @param s The string to capitalize
+ * @returns {string} The capitalized string
+ * @example titleCase("test") // "Test"
+ * @example titleCase("Test") // "Test"
+ * @example titleCase("test TeSt") // "Test test"
+ */
+export declare const titleCase: (s: string) => string;
+/**
+ * Converts a string removing left padding and dashes
+ *
+ * @param id The id to convert
+ * @returns {number} The converted id
+ * @example removeLeftPadding("00000000-0000-0000-0000-000000000001") // 1
+ * @example removeLeftPadding("00000000-0000-0000-0000-000000000010") // 10
+ */
+export declare const removeLeftPadding: (id: string) => number;

package/src/timePeriodConverter/timePeriodConverter.d.ts

@@ -0,0 +1,34 @@
+import { TimePeriod } from "../TimePeriod";
+/**
+ * Converts a time period to a list of daily intervals
+ *
+ * @param period The time period to convert
+ * @returns {Array<{ from: Date; to: Date }>} A list of daily intervals
+ * @example toDailyIntervals(TimePeriod.THIS_MONTH) // [{ from: "2021-05-01T00:00:00.000Z", to: "2021-05-31T23:59:59.999Z" }]
+ */
+export declare function toDailyIntervals(period: TimePeriod): {
+    from: Date;
+    to: Date;
+}[];
+/**
+ * Converts a time period to an interval
+ *
+ * @param period The time period to convert
+ * @returns {{ from: Date; to: Date }} An interval
+ * @example toInterval(TimePeriod.THIS_MONTH) // { from: "2021-05-01T00:00:00.000Z", to: "2021-05-31T23:59:59.999Z" }
+ */
+export declare function toInterval(period: TimePeriod): {
+    from: Date;
+    to: Date;
+};
+/**
+ * Converts a time period to a list of months
+ *
+ * @param period The time period to convert
+ * @returns {Array<{ year: number; month: number }>} A list of months
+ * @example toMonths(TimePeriod.THIS_MONTH) // [{ year: 2021, month: 5 }]
+ */
+export declare function toDates(period: TimePeriod): {
+    from: string;
+    to: string;
+};

package/src/typeUtils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Infer the element type from the array type
+ *
+ * Use case:
+ * You have a GraphQL payload that returns an array of assets with a specific signature
+ * and wish be specific instead of just using Partial<Asset> as input for a component
+ *
+ * Example:
+ * interface SomeInterface {
+ *  asset: ArrayElement<SomeAssetsQueryQuery["assets"]["payload"]>;
+ * }
+ *
+ */
+export type ArrayElement<A> = A extends readonly (infer T)[] ? T : never;
+/**
+ * Use with filter() to remove null and undefined from an array
+ *
+ * Example:
+ * [1, 2, 0, null].filter(nonNullable) // number[]
+ *
+ */
+export declare const nonNullable: <T>(value: T) => value is NonNullable<T>;
+type Truthy<T> = T extends false | "" | 0 | null | undefined ? never : T;
+/**
+ * Use with filter() to remove not-truthy items from an array
+ *
+ * Example:
+ * [1, 2, 0, null].filter(truthy) // number[]
+ *
+ */
+export declare const truthy: <T>(value: T) => value is Truthy<T>;
+export {};