@cruncher/adapter-utils/dist/logTypes.js

Utility functions for Cruncher adapters.

import { formatDataTime } from "./formatters";
export const asStringFieldOrUndefined = (field) => {
    if (field?.type === "string") {
        return field;
    }
    return undefined;
};
export const asStringField = (field) => {
    const result = asStringFieldOrUndefined(field);
    if (!result) {
        return {
            type: "string",
            value: "",
            errors: ["Invalid string"],
        };
    }
    return result;
};
export const asNumberFieldOrUndefined = (field) => {
    if (field?.type === "number") {
        return field;
    }
    if (typeof field?.value === "number") {
        // if field value is numeric - we can cast it to number
        return {
            type: "number",
            value: field.value,
        };
    }
    return undefined;
};
export const isNumberField = (field) => {
    return field?.type === "number" || typeof field?.value === "number";
};
export const asNumberField = (field) => {
    const result = asNumberFieldOrUndefined(field);
    if (!result) {
        return {
            type: "number",
            value: NaN,
            errors: ["Invalid number"],
        };
    }
    return result;
};
export const asJson = (field) => {
    if (!field) {
        return "<null>";
    }
    if (field.type === "object") {
        const results = {};
        for (const key in field.value) {
            results[key] = asJson(field.value[key]);
        }
        return JSON.stringify(results);
    }
    if (field.type === "array") {
        return JSON.stringify(field.value.map(asJson));
    }
    return field.value.toString();
};
export const asDisplayString = (field) => {
    if (!field) {
        return "<null>";
    }
    if (field.type === "date") {
        return formatDataTime(field.value);
    }
    if (field.type === "object" || field.type === "array") {
        return asJson(field);
    }
    return field.value.toString();
};
export const asDateField = (field) => {
    if (field?.type === "date") {
        return field;
    }
    if (typeof field?.value === "number") {
        return {
            type: "date",
            value: field.value,
        };
    }
    return {
        type: "date",
        value: 0,
        errors: ["Invalid date"],
    };
};
export const getTimeFromProcessedData = (data) => {
    if (data.object._time) {
        return asDateField(data.object._time).value;
    }
    return 0;
};
export const compareProcessedData = (a, b) => {
    return getTimeFromProcessedData(b) - getTimeFromProcessedData(a);
};
export const isNotDefined = (field) => {
    return field === undefined || field === null;
};
export const isHashableField = (field) => {
    return (field?.type === "number" ||
        field?.type === "string" ||
        field?.type === "date");
};
export const toJsonObject = (data) => {
    const result = {};
    for (const key in data.object) {
        if (isNotDefined(data.object[key])) {
            result[key] = data.object[key];
            continue;
        }
        const field = data.object[key];
        if (field.type === "object" || field.type === "array") {
            result[key] = asJson(field);
            continue;
        }
        result[key] = field.value;
    }
    return result;
};
export const processField = (field) => {
    if (field === null || field === undefined) {
        return null;
    }
    if (typeof field === "number") {
        return {
            type: "number",
            value: field,
        };
    }
    else if (field instanceof Date) {
        return {
            type: "date",
            value: field.getTime(),
        };
    }
    else if (typeof field === "boolean") {
        return {
            type: "boolean",
            value: field,
        };
    }
    else if (Array.isArray(field)) {
        return {
            type: "array",
            value: field.map((item) => processField(item)),
        };
    }
    else if (typeof field === "object") {
        const objectFields = {};
        Object.entries(field ?? {}).forEach(([key, value]) => {
            objectFields[key] = processField(value);
        });
        return {
            type: "object",
            raw: field,
            value: objectFields,
        };
    }
    else if (typeof field === "string") {
        // try to parse as number
        if (/^\d+(?:\.\d+)?$/.test(field)) {
            return {
                type: "number",
                value: parseFloat(field),
            };
        }
        return {
            type: "string",
            value: field,
        };
    }
    throw new Error(`Unsupported field type: ${typeof field}`);
};
//# sourceMappingURL=logTypes.js.map