@cognite/reveal-components 1.0.0

package/dist/ui/query/useSearchAssetsMappedPointCloudAnnotations.d.ts

@@ -0,0 +1,6 @@
+import { UseQueryResult } from '@tanstack/react-query';
+import { AddModelOptions } from '@cognite/reveal';
+import { CogniteClient } from '@cognite/sdk';
+import { AssetInstance } from '../../utilities/instances';
+export declare const useAllAssetsMappedPointCloudAnnotations: (sdk: CogniteClient, models: AddModelOptions[]) => UseQueryResult<AssetInstance[]>;
+export declare const useSearchAssetsMappedPointCloudAnnotations: (models: AddModelOptions[], sdk: CogniteClient, query: string) => UseQueryResult<AssetInstance[] | null>;

package/dist/ui/query/useSearchAssetsMappedPointCloudAnnotations.js

@@ -0,0 +1,48 @@
+import { isClassicAsset as e } from "../../utilities/instances/typeGuards.js";
+import "../../utilities/instances/index.js";
+import { useFdmSdk as t } from "../components/RevealCanvas/SDKProvider.js";
+import { getAssetsMappedPointCloudAnnotations as n } from "../../data-providers/network/getAssetMappedPointCloudAnnotations.js";
+import { useQuery as r } from "@tanstack/react-query";
+//#region libs/shared/reveal-components/src/ui/query/useSearchAssetsMappedPointCloudAnnotations.ts
+var i = (e, i) => {
+	let a = t();
+	return r({
+		queryKey: [
+			"reveal",
+			"react-components",
+			"all-assets-mapped-point-cloud-annotations",
+			i
+		],
+		queryFn: async () => {
+			let t = i.map((e) => ({
+				modelId: e.modelId,
+				revisionId: e.revisionId,
+				sourceType: "classic"
+			}));
+			return await n(t, void 0, e, a);
+		},
+		staleTime: Infinity
+	});
+}, a = (t, n, a) => {
+	let { data: o, isFetched: s } = i(n, t);
+	return r({
+		queryKey: [
+			"reveal",
+			"react-components",
+			"search-assets-mapped-point-cloud-annotations",
+			a,
+			t
+		],
+		queryFn: async () => a === "" ? o ?? null : o?.filter((t) => {
+			if (e(t)) {
+				let e = t.name.toLowerCase().includes(a.toLowerCase()), n = t.description?.toLowerCase().includes(a.toLowerCase());
+				return e || n;
+			}
+			return !1;
+		}) ?? [],
+		staleTime: Infinity,
+		enabled: s && o !== void 0
+	});
+};
+//#endregion
+export { i as useAllAssetsMappedPointCloudAnnotations, a as useSearchAssetsMappedPointCloudAnnotations };

package/dist/ui/query/useSearchMappedEquipmentAssetMappings.context.d.ts

@@ -0,0 +1,9 @@
+import { Context } from 'react';
+import { useSDK } from '../components/RevealCanvas/SDKProvider';
+import { useIsCoreDmOnly } from '../hooks/useIsCoreDmOnly';
+export type UseSearchMappedEquipmentAssetMappingsDependencies = {
+    useSDK: typeof useSDK;
+    useIsCoreDmOnly: typeof useIsCoreDmOnly;
+};
+export declare const defaultUseSearchMappedEquipmentAssetMappingsDependencies: UseSearchMappedEquipmentAssetMappingsDependencies;
+export declare const UseSearchMappedEquipmentAssetMappingsContext: Context<UseSearchMappedEquipmentAssetMappingsDependencies>;

package/dist/ui/query/useSearchMappedEquipmentAssetMappings.context.js

@@ -0,0 +1,10 @@
+import { useSDK as e } from "../components/RevealCanvas/SDKProvider.js";
+import { useIsCoreDmOnly as t } from "../hooks/useIsCoreDmOnly.js";
+import { createContext as n } from "react";
+//#region libs/shared/reveal-components/src/ui/query/useSearchMappedEquipmentAssetMappings.context.ts
+var r = {
+	useSDK: e,
+	useIsCoreDmOnly: t
+}, i = n(r);
+//#endregion
+export { i as UseSearchMappedEquipmentAssetMappingsContext, r as defaultUseSearchMappedEquipmentAssetMappingsDependencies };

package/dist/ui/query/useSearchMappedEquipmentAssetMappings.d.ts

@@ -0,0 +1,21 @@
+import { UseInfiniteQueryResult } from '@tanstack/react-query';
+import { AddModelOptions } from '@cognite/reveal';
+import { Asset, CogniteClient, ListResponse } from '@cognite/sdk';
+import { ClassicCadAssetMapping } from '../../data-providers/cache/cad/assetMappingTypes';
+export type ClassicCadModelMappings = {
+    model: AddModelOptions;
+    mappings: ListResponse<ClassicCadAssetMapping[]>;
+};
+export type ClassicCadModelMappingsWithAssets = ClassicCadModelMappings & {
+    assets: Asset[];
+};
+export type AssetPage = {
+    assets: Asset[];
+    nextCursor: string | undefined;
+};
+export type ModelAssetPage = {
+    modelsAssets: ClassicCadModelMappingsWithAssets[];
+    nextCursor: string | undefined;
+};
+export declare const useAllMappedEquipmentAssetMappings: (models: AddModelOptions[], userSdk?: CogniteClient, limit?: number) => UseInfiniteQueryResult<ClassicCadModelMappingsWithAssets[], Error>;
+export declare const useMappingsForAssetIds: (models: AddModelOptions[], assetIds: number[]) => UseInfiniteQueryResult<ClassicCadModelMappingsWithAssets[], Error>;

package/dist/ui/query/useSearchMappedEquipmentAssetMappings.js

@@ -0,0 +1,95 @@
+import { isDefined as e } from "../../utilities/isDefined.js";
+import { isClassicCadAssetMapping as t } from "../../data-providers/cache/cad/assetMappingTypes.js";
+import { convertToHybridAssetMapping as n } from "../../data-providers/cache/cad/rawAssetMappingTypes.js";
+import { getAssetsFromAssetMappings as r } from "../../data-providers/network/cad/getAssetsFromAssetMappings.js";
+import { UseSearchMappedEquipmentAssetMappingsContext as i } from "./useSearchMappedEquipmentAssetMappings.context.js";
+import { useContext as a } from "react";
+import { useInfiniteQuery as o } from "@tanstack/react-query";
+//#region libs/shared/reveal-components/src/ui/query/useSearchMappedEquipmentAssetMappings.tsx
+var s = (s, c, u = 1e3) => {
+	let { useSDK: d, useIsCoreDmOnly: f } = a(i), p = d(c), m = f(), h = s.length > 0 && !m;
+	return o({
+		queryKey: [
+			"reveal",
+			"react-components",
+			"all-mapped-equipment-asset-mappings",
+			u,
+			...s.map((e) => [e.modelId, e.revisionId])
+		],
+		queryFn: async ({ pageParam: i }) => {
+			let a = s.map(async (r) => {
+				let a = (i ?? s.map((e) => ({
+					cursor: "start",
+					model: e
+				}))).find((e) => e.model.modelId === r.modelId && e.model.revisionId === r.revisionId)?.cursor;
+				if (a === void 0) return {
+					mappings: { items: [] },
+					model: r
+				};
+				let o = await p.assetMappings3D.filter(r.modelId, r.revisionId, {
+					cursor: a === "start" ? void 0 : a,
+					limit: u
+				});
+				return {
+					mappings: {
+						items: o.items.flatMap(n).filter(e).filter(t),
+						nextCursor: o.nextCursor
+					},
+					model: r
+				};
+			}), o = await Promise.all(a);
+			return await r(p, o);
+		},
+		staleTime: Infinity,
+		getNextPageParam: l,
+		enabled: h
+	});
+}, c = (s, c) => {
+	let { useSDK: u, useIsCoreDmOnly: d } = a(i), f = u(), p = d(), m = s.length > 0 && !p;
+	return o({
+		queryKey: [
+			"reveal",
+			"react-components",
+			"mappings-for-asset-ids",
+			...s.map((e) => [e.modelId, e.revisionId]),
+			...c
+		],
+		queryFn: async ({ pageParam: i }) => {
+			let a = s.map(async (r) => {
+				let a = (i ?? s.map((e) => ({
+					cursor: "start",
+					model: e
+				}))).find((e) => e.model.modelId === r.modelId && e.model.revisionId === r.revisionId)?.cursor;
+				if (a === void 0 || c.length === 0) return {
+					mappings: { items: [] },
+					model: r
+				};
+				let o = await f.assetMappings3D.filter(r.modelId, r.revisionId, {
+					cursor: a === "start" ? void 0 : a,
+					limit: 1e3,
+					filter: { assetIds: c }
+				});
+				return {
+					mappings: {
+						items: o.items.flatMap(n).filter(e).filter(t),
+						nextCursor: o.nextCursor
+					},
+					model: r
+				};
+			}), o = await Promise.all(a);
+			return await r(f, o);
+		},
+		staleTime: Infinity,
+		getNextPageParam: l,
+		enabled: m
+	});
+};
+function l(e) {
+	let t = e.map(({ mappings: e, model: t }) => ({
+		cursor: e.nextCursor,
+		model: t
+	})).filter((e) => e.cursor !== void 0);
+	if (t.length !== 0) return t;
+}
+//#endregion
+export { s as useAllMappedEquipmentAssetMappings, c as useMappingsForAssetIds };

package/dist/ui/query/useSearchMappedEquipmentFDM.d.ts

@@ -0,0 +1,12 @@
+import { ViewDefinition } from '@cognite/sdk';
+import { NodeItem, Source, SimpleSource } from '../../data-providers/FdmSDK';
+import { ThreeDResourceIdentifier } from '../../data-providers/types/resources';
+export type InstancesWithView<PropertyType = Record<string, unknown>> = {
+    view: Source;
+    instances: Array<NodeItem<PropertyType>>;
+};
+export type InstancesWithViewDefinition<PropertyType = Record<string, unknown>> = {
+    view: ViewDefinition;
+    instances: Array<NodeItem<PropertyType>>;
+};
+export declare function useFilterNodesByMappedToModelsCallback(models: ThreeDResourceIdentifier[], includeIndirectRelations: boolean): (identifiers: NodeItem[], view: SimpleSource) => Promise<NodeItem[]>;

package/dist/ui/query/useSearchMappedEquipmentFDM.js

@@ -0,0 +1,42 @@
+import { useFdmSdk as e } from "../components/RevealCanvas/SDKProvider.js";
+import { useFdm3dDataProvider as t } from "../../data-providers/cache/CacheProvider.js";
+import { useCallback as n } from "react";
+import { useQueryClient as r } from "@tanstack/react-query";
+//#region libs/shared/reveal-components/src/ui/query/useSearchMappedEquipmentFDM.tsx
+function i(i, a) {
+	let s = t(), c = e(), l = r();
+	return n(async (e, t) => {
+		if (s === void 0) return [];
+		let n = await o(l, c, t);
+		return (await s.filterNodesByMappedTo3d([{
+			instances: e,
+			view: n
+		}], i, a)).flatMap((e) => e.instances);
+	}, [
+		a,
+		i,
+		s,
+		c,
+		l
+	]);
+}
+function a(e) {
+	return e.map((e) => ({
+		...e,
+		type: "view"
+	}));
+}
+async function o(e, t, n) {
+	return await e.fetchQuery({
+		queryKey: [
+			"reveal",
+			"react-components",
+			"search-mapped-fdm",
+			"get-view-definitions-from-simple-source",
+			n
+		],
+		queryFn: async () => (await t.getViewsByIds(a([n]))).items[0]
+	});
+}
+//#endregion
+export { i as useFilterNodesByMappedToModelsCallback };

package/dist/ui/query/useTimeseriesByIdsQuery.d.ts

@@ -0,0 +1,3 @@
+import { UseQueryResult } from '@tanstack/react-query';
+import { Timeseries, IdEither } from '@cognite/sdk';
+export declare function useTimeseriesByIdsQuery(ids: IdEither[]): UseQueryResult<Timeseries[]>;

package/dist/ui/query/useTimeseriesByIdsQuery.js

@@ -0,0 +1,15 @@
+import { queryKeys as e } from "../../utilities/queryKeys.js";
+import { useSDK as t } from "../components/RevealCanvas/SDKProvider.js";
+import { getTimeseriesByIds as n } from "../hooks/network/getTimeseriesByIds.js";
+import { useQuery as r } from "@tanstack/react-query";
+//#region libs/shared/reveal-components/src/ui/query/useTimeseriesByIdsQuery.ts
+function i(i) {
+	let a = t();
+	return r({
+		queryKey: e.timeseriesById(i),
+		queryFn: async () => await n(a, i),
+		enabled: i.length > 0
+	});
+}
+//#endregion
+export { i as useTimeseriesByIdsQuery };

package/dist/ui/query/useTimeseriesLatestDatapointQuery.d.ts

@@ -0,0 +1,2 @@
+import { Datapoints } from '@cognite/sdk/';
+export declare const useTimeseriesLatestDatapointQuery: (timeseriesIds: number[], isLoadingAssetIdsAndTimeseries: boolean) => Datapoints[] | undefined;

package/dist/ui/query/useTimeseriesLatestDatapointQuery.js

@@ -0,0 +1,15 @@
+import { queryKeys as e } from "../../utilities/queryKeys.js";
+import { useSDK as t } from "../components/RevealCanvas/SDKProvider.js";
+import { getTimeseriesLatestDatapoints as n } from "../hooks/network/getTimeseriesLatestDatapoints.js";
+import { useQuery as r } from "@tanstack/react-query";
+//#region libs/shared/reveal-components/src/ui/query/useTimeseriesLatestDatapointQuery.ts
+var i = (i, a) => {
+	let o = t(), s = i.map((e) => ({ id: e })), { data: c } = r({
+		queryKey: [e.timeseriesLatestDatapoint(), i],
+		queryFn: async () => await n(o, s),
+		enabled: !a && s.length > 0
+	});
+	return c;
+};
+//#endregion
+export { i as useTimeseriesLatestDatapointQuery };

package/dist/utilities/PickReturn.d.ts

@@ -0,0 +1 @@
+export type PickReturn<T extends (...args: any[]) => any, U extends keyof ReturnType<T>> = (...args: Parameters<T>) => Pick<ReturnType<T>, U>;

package/dist/utilities/TextWithClickableLink.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement } from 'react';
+export declare function TextWithClickableLink({ content, }: {
+    content: string;
+}): ReactElement;

package/dist/utilities/TextWithClickableLink.js

@@ -0,0 +1,25 @@
+import { getUrlRegex as e } from "./getUrlRegex.js";
+import { useMemo as t } from "react";
+import { jsx as n } from "react/jsx-runtime";
+//#region libs/shared/reveal-components/src/utilities/TextWithClickableLink.tsx
+function r({ content: r }) {
+	let i = t(() => r.split(e()).filter((e) => e !== "").map((t, r) => {
+		let i = e().test(t), a = (() => {
+			try {
+				return new URL(t) !== void 0;
+			} catch {
+				return !1;
+			}
+		})();
+		return i && a ? /* @__PURE__ */ n("a", {
+			href: t,
+			target: "_blank",
+			rel: "noopener noreferrer",
+			className: "underline cursor-pointer",
+			children: t
+		}, r) : /* @__PURE__ */ n("span", { children: t }, r);
+	}), [r]);
+	return /* @__PURE__ */ n("span", { children: i });
+}
+//#endregion
+export { r as TextWithClickableLink };

package/dist/utilities/assertNever.d.ts

@@ -0,0 +1 @@
+export declare function assertNever(x: never, message?: string): never;

package/dist/utilities/assertNever.js

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/utilities/assertNever.ts
+function e(e, t) {
+	throw Error(t ?? "Unexpected object: " + e);
+}
+//#endregion
+export { e as assertNever };

package/dist/utilities/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_QUERY_STALE_TIME: number;
+export declare const METERS_TO_FEET = 3.28084;
+export declare const FEET_TO_INCHES = 12;
+export declare const EMPTY_ARRAY: never[];
+export declare const DEFAULT_GLOBAL_TABLE_MAX_RESULT_LIMIT = 1000;

package/dist/utilities/constants.js

@@ -0,0 +1,6 @@
+//#region libs/shared/reveal-components/src/utilities/constants.ts
+var e = 6e5, t = [];
+Object.freeze(t);
+var n = 1e3;
+//#endregion
+export { n as DEFAULT_GLOBAL_TABLE_MAX_RESULT_LIMIT, e as DEFAULT_QUERY_STALE_TIME, t as EMPTY_ARRAY };

package/dist/utilities/convertAssetMetadataToLowerCase.d.ts

@@ -0,0 +1,2 @@
+import { Asset } from '@cognite/sdk';
+export declare function convertAssetMetadataKeysToLowerCase(asset: Asset): Asset;

package/dist/utilities/convertAssetMetadataToLowerCase.js

@@ -0,0 +1,9 @@
+//#region libs/shared/reveal-components/src/utilities/convertAssetMetadataToLowerCase.ts
+function e(e) {
+	return {
+		...e,
+		metadata: Object.fromEntries(Object.entries(e.metadata ?? {}).map(([e, t]) => [e.toLowerCase(), t]))
+	};
+}
+//#endregion
+export { e as convertAssetMetadataKeysToLowerCase };

package/dist/utilities/createSimpleHash.d.ts

@@ -0,0 +1 @@
+export declare function createSimpleHash(parts: string[]): string;

package/dist/utilities/createSimpleHash.js

@@ -0,0 +1,13 @@
+//#region libs/shared/reveal-components/src/utilities/createSimpleHash.ts
+function e(e) {
+	let n = 2166136261;
+	for (let r of e) n = t(r, n), n = t("", n);
+	return n.toString(16).padStart(8, "0");
+}
+function t(e, t = 2166136261) {
+	let n = t >>> 0;
+	for (let t = 0; t < e.length; t++) n ^= e.charCodeAt(t), n += (n << 1) + (n << 4) + (n << 7) + (n << 8) + (n << 24);
+	return n >>> 0;
+}
+//#endregion
+export { e as createSimpleHash };

package/dist/utilities/cursoring/autoCursoringProvider.d.ts

@@ -0,0 +1,16 @@
+import { QueryDataProvider } from './dataPaginator';
+export type CursorQueryFunction<T, Cursor = string> = (params: {
+    limit?: number;
+    cursor?: Cursor;
+}) => Promise<{
+    items: T[];
+    nextCursor?: Cursor;
+}>;
+export declare class AutoCursoringProvider<T, Cursor = string> implements QueryDataProvider<T[]> {
+    private _queryDefinition;
+    private _maxLimit;
+    private _nextCursor;
+    private _exhausted;
+    constructor(_queryDefinition: CursorQueryFunction<T, Cursor>, _maxLimit?: number);
+    fetchNext(): Promise<T[] | undefined>;
+}

package/dist/utilities/cursoring/autoCursoringProvider.js

@@ -0,0 +1,20 @@
+//#region libs/shared/reveal-components/src/utilities/cursoring/autoCursoringProvider.ts
+var e = class {
+	_queryDefinition;
+	_maxLimit;
+	_nextCursor = void 0;
+	_exhausted = !1;
+	constructor(e, t = 1e3) {
+		this._queryDefinition = e, this._maxLimit = t;
+	}
+	async fetchNext() {
+		if (this._exhausted) return;
+		let { items: e, nextCursor: t } = await this._queryDefinition({
+			limit: this._maxLimit,
+			cursor: this._nextCursor
+		});
+		return this._nextCursor = t, (t === void 0 || e.length < this._maxLimit) && (this._exhausted = !0), e;
+	}
+};
+//#endregion
+export { e as AutoCursoringProvider };

package/dist/utilities/cursoring/dataAccumulator.d.ts

@@ -0,0 +1,13 @@
+import { QueryDataProvider } from './dataPaginator';
+export declare class DataAccumulator<T, QueryResult = T> {
+    private readonly _queryDataProvider;
+    private readonly _merger;
+    private _isExhausted;
+    private _accumulatedData;
+    private _currentFetchPromise;
+    constructor(_queryDataProvider: QueryDataProvider<QueryResult>, _merger: (accumulatedResult: T, newResult: QueryResult) => T, initialValue: T);
+    getAccumulatedData(): T;
+    accumulateNext(): Promise<T>;
+    isExhausted(): boolean;
+    accumulateAllData(): Promise<T>;
+}

package/dist/utilities/cursoring/dataAccumulator.js

@@ -0,0 +1,29 @@
+//#region libs/shared/reveal-components/src/utilities/cursoring/dataAccumulator.ts
+var e = class {
+	_queryDataProvider;
+	_merger;
+	_isExhausted = !1;
+	_accumulatedData;
+	_currentFetchPromise = void 0;
+	constructor(e, t, n) {
+		this._queryDataProvider = e, this._merger = t, this._accumulatedData = n;
+	}
+	getAccumulatedData() {
+		return this._accumulatedData;
+	}
+	async accumulateNext() {
+		return this._isExhausted ? this._accumulatedData : this._currentFetchPromise === void 0 ? (this._currentFetchPromise = (async () => {
+			let e = await this._queryDataProvider.fetchNext();
+			return e === void 0 ? (this._isExhausted = !0, this._accumulatedData) : this._merger(this._accumulatedData, e);
+		})(), this._accumulatedData = await this._currentFetchPromise, this._currentFetchPromise = void 0, this._accumulatedData) : this._currentFetchPromise;
+	}
+	isExhausted() {
+		return this._isExhausted;
+	}
+	async accumulateAllData() {
+		for (; !this.isExhausted();) await this.accumulateNext();
+		return this.getAccumulatedData();
+	}
+};
+//#endregion
+export { e as DataAccumulator };

package/dist/utilities/cursoring/dataPaginator.d.ts

@@ -0,0 +1,10 @@
+export interface QueryDataProvider<T> {
+    fetchNext(): Promise<T | undefined>;
+}
+export declare class DataPaginator<T> {
+    private _queryDataProvider;
+    private _remainingResults;
+    private _exhausted;
+    constructor(_queryDataProvider: QueryDataProvider<T[]>);
+    getNextPage(count: number): Promise<T[] | undefined>;
+}

package/dist/utilities/cursoring/dataPaginator.js

@@ -0,0 +1,23 @@
+//#region libs/shared/reveal-components/src/utilities/cursoring/dataPaginator.ts
+var e = class {
+	_queryDataProvider;
+	_remainingResults = [];
+	_exhausted = !1;
+	constructor(e) {
+		this._queryDataProvider = e;
+	}
+	async getNextPage(e) {
+		if (this._exhausted) return;
+		let t = this._remainingResults;
+		for (; t.length < e;) {
+			let e = await this._queryDataProvider.fetchNext();
+			if (e === void 0) break;
+			t.push(...e);
+		}
+		if (t.length < e && (this._exhausted = !0), t.length === 0) return;
+		let n = t.slice(e);
+		return this._remainingResults = n, t.slice(0, e);
+	}
+};
+//#endregion
+export { e as DataPaginator };

package/dist/utilities/cursoring/index.d.ts

@@ -0,0 +1,2 @@
+export { DataPaginator, type QueryDataProvider } from './dataPaginator';
+export { AutoCursoringProvider, type CursorQueryFunction, } from './autoCursoringProvider';

package/dist/utilities/date-time-utils/constants.d.ts

@@ -0,0 +1,7 @@
+import { default as relativeTime } from 'dayjs/plugin/relativeTime';
+type RelativeTimeOption = Parameters<typeof relativeTime>[0];
+export declare const RELATIVE_TIME_CONFIG: RelativeTimeOption;
+export declare const DEFAULT_DATE_TIME_FORMAT = "ll LT";
+export declare const DEFAULT_DATE_FORMAT = "ll";
+export declare const DEFAULT_TIME_FORMAT = "LT";
+export {};

package/dist/utilities/date-time-utils/constants.js

@@ -0,0 +1,54 @@
+//#region libs/shared/reveal-components/src/utilities/date-time-utils/constants.ts
+var e = { thresholds: [
+	{
+		l: "s",
+		r: 59,
+		d: "second"
+	},
+	{
+		l: "m",
+		r: 1
+	},
+	{
+		l: "mm",
+		r: 59,
+		d: "minute"
+	},
+	{
+		l: "h",
+		r: 1
+	},
+	{
+		l: "hh",
+		r: 23,
+		d: "hour"
+	},
+	{
+		l: "d",
+		r: 1
+	},
+	{
+		l: "dd",
+		r: 29,
+		d: "day"
+	},
+	{
+		l: "M",
+		r: 1
+	},
+	{
+		l: "MM",
+		r: 11,
+		d: "month"
+	},
+	{
+		l: "y",
+		r: 1
+	},
+	{
+		l: "yy",
+		d: "year"
+	}
+] }, t = "ll LT";
+//#endregion
+export { t as DEFAULT_DATE_TIME_FORMAT, e as RELATIVE_TIME_CONFIG };

package/dist/utilities/date-time-utils/format-date-time.d.ts

@@ -0,0 +1,39 @@
+import { default as dayjs } from 'dayjs';
+import { DateTimeFormatArguments, DateTimeFormatOptions } from './types';
+/**
+ * Formats a given date and time based on the provided options.
+ *
+ * @param options - The options for formatting the date and time.
+ * @param options.date - The date to be formatted.
+ * @param options.language - The language locale to be used for formatting.
+ * @param options.showAbsolute - Whether to show the absolute date and time.
+ * @param options.format - The format to be used for the absolute date and time.
+ * @param options.thresholdInHours - The threshold in hours to determine if the date should be shown as relative or absolute.
+ *
+ * @returns The formatted date and time as a string.
+ */
+export declare const formatDateTime: (options: DateTimeFormatArguments) => string;
+/**
+ * Returns a relative time string (e.g., "a few seconds ago") based on the provided date and language options.
+ *
+ * @param options - An object containing the date and language options.
+ * @param options.date - The date to be formatted.
+ * @param options.language - (Optional) The language locale to use for formatting.
+ *
+ * @returns A string representing the relative time from the current date.
+ */
+export declare const getRelativeDateTime: (options: DateTimeFormatOptions) => string;
+/**
+ * Formats a given date into an absolute date-time string based on the provided options.
+ *
+ * @param options - An object containing the date, language, and format options.
+ * @param options.date - The date to be formatted.
+ * @param options.language - (Optional) The language locale to use for formatting.
+ * @param options.format - (Optional) The format string to use for formatting the date.
+ *
+ * @returns A string representing the formatted date-time.
+ */
+export declare const getAbsoluteDateTime: (options: DateTimeFormatOptions) => string;
+export declare const isToday: (date: dayjs.ConfigType) => boolean;
+export declare const isTomorrow: (date: dayjs.ConfigType) => boolean;
+export declare const isYesterday: (date: dayjs.ConfigType) => boolean;

package/dist/utilities/date-time-utils/format-date-time.js

@@ -0,0 +1,37 @@
+import { RELATIVE_TIME_CONFIG as e } from "./constants.js";
+import t from "dayjs";
+import n from "dayjs/plugin/isToday";
+import r from "dayjs/plugin/isTomorrow";
+import i from "dayjs/plugin/isYesterday";
+import a from "dayjs/plugin/localizedFormat";
+import o from "dayjs/plugin/relativeTime";
+import "dayjs/locale/de";
+import "dayjs/locale/en";
+import "dayjs/locale/es";
+import "dayjs/locale/fr";
+import "dayjs/locale/it";
+import "dayjs/locale/lv";
+import "dayjs/locale/nl";
+import "dayjs/locale/pt";
+import "dayjs/locale/sv";
+import "dayjs/locale/ko";
+import "dayjs/locale/zh";
+import "dayjs/locale/ja";
+t.extend(o, e), t.extend(n), t.extend(r), t.extend(i), t.extend(a);
+var s = (e) => {
+	let { date: n, language: r, showAbsolute: i, format: a } = e, o = t(n);
+	return r !== void 0 && (o = o.locale(r)), i === void 0 && (e.thresholdInHours !== void 0 && Number.isInteger(e.thresholdInHours) ? o.isAfter(t().subtract(e.thresholdInHours, "hour")) && o.isBefore(t().add(e.thresholdInHours, "hour")) : o.isAfter(t().subtract(24, "hour")) && o.isBefore(t().add(24, "hour"))) ? c({ date: o }) : l({
+		date: o,
+		format: a
+	});
+}, c = (e) => {
+	let n = t(e.date);
+	return e.language !== void 0 && (n = n.locale(e.language)), n.fromNow();
+}, l = (e) => {
+	let n = t(e.date);
+	e.language !== void 0 && (n = n.locale(e.language));
+	let r = e.format ?? "ll LT";
+	return n.format(r);
+};
+//#endregion
+export { s as formatDateTime, l as getAbsoluteDateTime, c as getRelativeDateTime };