@thejob/util 1.0.0

package/dist/esm/common/utils.js

@@ -0,0 +1,372 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ExperienceLevel, ProficiencyLevel, UserCompletenessSchema, } from "@thejob/schema";
+import { customAlphabet } from "nanoid";
+export const removeEmpty = (obj) => {
+    // Check if the value is an object and not null
+    if (obj !== null && typeof obj === "object") {
+        // Iterate over each key in the object
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                const value = obj[key];
+                // Recursively remove empty properties from nested objects
+                if (typeof value === "object" && value !== null) {
+                    obj[key] = removeEmpty(value);
+                }
+                // Remove the property if it's null, undefined, or an empty string, array, or object
+                if (value === null ||
+                    value === undefined ||
+                    value === "" ||
+                    (typeof value === "object" && Object.keys(value).length === 0)) {
+                    delete obj[key];
+                }
+            }
+        }
+    }
+    return obj;
+};
+export const deepEqual = (obj1, obj2) => {
+    return (JSON.stringify(removeEmpty(obj1)) === JSON.stringify(removeEmpty(obj2)));
+};
+// export const getYupDefaults = <T>(schema: any) => {
+//   const defaultValues: any = {};
+//   for (const key in schema.fields) {
+//     const field = schema.fields[key];
+//     if (field?.type === "object") {
+//       defaultValues[key] = getYupDefaults(field); // Recursively get defaults for nested objects
+//     } else {
+//       defaultValues[key] = field.default ? field.getDefault() : undefined; // Use `getDefault` to get default value
+//     }
+//   }
+//   return defaultValues as T;
+// };
+const replaceEmptyObjectsWithNull = (obj) => {
+    if (typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => replaceEmptyObjectsWithNull(item));
+    }
+    const newObj = {};
+    let isEmpty = true;
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            const value = replaceEmptyObjectsWithNull(obj[key]);
+            newObj[key] = value;
+            if (typeof value === "object" &&
+                value !== null &&
+                Object.keys(value).length > 0) {
+                isEmpty = false;
+            }
+            else if (typeof value !== "undefined" &&
+                value !== null &&
+                value !== "") {
+                isEmpty = false;
+            }
+        }
+    }
+    return isEmpty && Object.keys(obj).length > 0 ? null : newObj;
+};
+export const getYupDefaults = (schema) => {
+    const defaultValues = schema.getDefault();
+    return replaceEmptyObjectsWithNull(defaultValues);
+};
+export const getFormDefaultValues = (inputValue, // TODO: Use react hook form default values type definition,,
+onComplete = () => null) => {
+    const isCallable = typeof inputValue === "function";
+    return async () => {
+        const values = isCallable ? await inputValue() : inputValue;
+        onComplete(values);
+        return values;
+    };
+};
+export const proficiencyLevelToRating = (level) => {
+    switch (level) {
+        case ProficiencyLevel.BasicAwareness:
+            return 1;
+        case ProficiencyLevel.Beginner:
+            return 2;
+        case ProficiencyLevel.Intermediate:
+            return 3;
+        case ProficiencyLevel.Advanced:
+            return 4;
+        case ProficiencyLevel.Expert:
+            return 5;
+        default:
+            return 0;
+    }
+};
+export const slugify = (str) => {
+    str = str?.trim(); // trim leading/trailing white space
+    str = str
+        ?.replace(/([a-z0-9])([A-Z])/g, "$1-$2") // Convert camelCase to camel-Case
+        .toLowerCase() // convert string to lowercase
+        .replace(/[^a-z0-9 -]/g, "") // remove any non-alphanumeric characters
+        .replace(/\s+/g, "-") // replace spaces with hyphens
+        .replace(/-+/g, "-"); // remove consecutive hyphens
+    return str;
+};
+export const getShortId = (size = 12) => {
+    const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    const nanoid = customAlphabet(alphabet, 12);
+    return nanoid(size);
+};
+export const minifyString = (seed, length = 10) => {
+    let alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    function createRandom() {
+        let a = 1664525;
+        let c = 1013904223;
+        let m = Math.pow(2, 32);
+        let state = 0;
+        for (let i = 0; i < seed.length; i++) {
+            state += seed.charCodeAt(i);
+        }
+        return function () {
+            state = (a * state + c) % m;
+            return state;
+        };
+    }
+    let random = createRandom();
+    let generatedString = "";
+    for (let i = 0; i < length; i++) {
+        let randomIndex = random() % alphabet.length;
+        generatedString += alphabet[randomIndex];
+    }
+    return generatedString;
+};
+/**
+ * Extracts the ID from a given string pattern.
+ * Assumes the ID is the last segment after the final hyphen.
+ *
+ * @param input - The string to extract the ID from.
+ * @returns The extracted ID or null if not found.
+ */
+export const extractShortID = (slug) => {
+    // Match the last hyphen followed by one or more characters
+    const match = slug.match(/-(\w+)$/);
+    // Return the first capturing group if a match is found
+    return match ? match[1] : null;
+};
+export const allResults = async (promises) => {
+    const results = await Promise.allSettled(promises);
+    return results.map((result) => result.status === "fulfilled" ? result.value : { error: result.reason });
+};
+export const sleep = async (duration) => {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve({});
+        }, duration);
+    });
+};
+export const hasOtherValue = (input) => {
+    return (input?.value === "others" ||
+        (Array.isArray(input?.value) && input?.value.includes("others")));
+};
+export const fromWithOtherValue = (input, displayFn = (value) => value) => {
+    if (!input)
+        return "Not avaiable";
+    if (hasOtherValue(input)) {
+        return input.otherValue || "Not Available";
+    }
+    else {
+        return displayFn(input);
+    }
+};
+export const isJSON = (value) => {
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};
+export const displayByName = (option) => {
+    return option?.name;
+};
+export const displayLocation = (location, display) => {
+    const { city, state, country, address } = location || {};
+    let keywords = [];
+    if (display === "address") {
+        keywords = [address];
+    }
+    else if (display === "medium") {
+        keywords = [city, state, country];
+    }
+    else if (display === "small") {
+        keywords = [city, country];
+    }
+    else {
+        keywords = [country];
+    }
+    const result = keywords.filter((value) => !!value).join(", ");
+    return result || "Not Available";
+};
+/**
+ * Generates a random integer between two given values (inclusive).
+ *
+ * @param {number} min - The minimum value (inclusive).
+ * @param {number} max - The maximum value (inclusive).
+ * @returns {number} A random integer between min and max.
+ */
+export const getRandomInt = (min, max) => {
+    if (min > max) {
+        throw new Error("Min value must be less than or equal to max value.");
+    }
+    const minCeiled = Math.ceil(min);
+    const maxFloored = Math.floor(max);
+    return Math.floor(Math.random() * (maxFloored - minCeiled + 1)) + minCeiled;
+};
+/**
+ * Generates a random floating-point number between two given values (inclusive).
+ *
+ * @param {number} min - The minimum value (inclusive).
+ * @param {number} max - The maximum value (inclusive).
+ * @returns {number} A random floating-point number between min and max.
+ */
+export const getRandomFloat = (min, max) => {
+    if (min > max) {
+        throw new Error("Min value must be less than or equal to max value.");
+    }
+    return Math.random() * (max - min) + min;
+};
+export const displayNameLabel = (name, type = "full") => {
+    if (!name) {
+        return "Not available";
+    }
+    if (typeof name === "string") {
+        return name;
+    }
+    const { first, last } = name;
+    if (type === "full") {
+        return `${first} ${last}`;
+    }
+    else if (type === "first") {
+        return first;
+    }
+    else if (type === "last") {
+        return last;
+    }
+    else {
+        return "Render Failed";
+    }
+};
+export const displayMobileNumberLabel = (mobileNumber, options) => {
+    const { number, country } = mobileNumber;
+    const { name, dial_code } = country;
+    if (!options?.countryName) {
+        return `${dial_code} ${number}`;
+    }
+    return `${name} (${dial_code}) ${number}`;
+};
+export const toPositiveWholeNumber = (value) => {
+    if (typeof value !== "number") {
+        return 0;
+    }
+    const wholePercentage = Math.round(value); // Round to the nearest whole number
+    return wholePercentage < 0 ? 0 : wholePercentage; // Ensure the value is positive
+};
+export const formatNumberToKMB = (num) => {
+    if (num < 1000) {
+        return num.toString();
+    }
+    else if (num < 1000000) {
+        return (num / 1000).toFixed(1) + "K";
+    }
+    else if (num < 1000000000) {
+        return (num / 1000000).toFixed(1) + "M";
+    }
+    else {
+        return (num / 1000000000).toFixed(1) + "B";
+    }
+};
+export const formatCountWithLabel = (count, options) => {
+    const { singularLabel, pluralLabel, zeroCountLabel } = options;
+    if (count === undefined || count === 0) {
+        return zeroCountLabel || `No ${pluralLabel}`;
+    }
+    else {
+        const formattedCount = formatNumberToKMB(count);
+        const label = count > 1 ? pluralLabel : singularLabel;
+        return `${formattedCount} ${label}`;
+    }
+};
+/**
+ * Recursively parses a dirty fields object to detect if the form or a specific field is dirty.
+ *
+ * @param dirtyFields The object representing the dirty state of form fields.
+ * @param fieldName (Optional) The name of a specific field to check for dirtiness.
+ * @returns True if the form or the specified field is dirty, false otherwise.
+ */
+export const isFormDirty = (dirtyFields, //PickFrom<FormState<any>, "dirtyFields">,
+fieldName) => {
+    if (fieldName) {
+        const field = dirtyFields[fieldName];
+        if (typeof field === "boolean") {
+            return field;
+        }
+        else if (typeof field === "object" && field !== null) {
+            // If the field is an object or array, recursively check its contents
+            return isFormDirty(field);
+        }
+        return false; // FieldName not found or not a boolean/object
+    }
+    // If no fieldName is provided, check the entire form
+    for (const key in dirtyFields) {
+        if (Object.prototype.hasOwnProperty.call(dirtyFields, key)) {
+            const value = dirtyFields[key];
+            if (typeof value === "boolean") {
+                if (value === true) {
+                    return true; // Found a dirty boolean field
+                }
+            }
+            else if (typeof value === "object" && value !== null) {
+                // Recursively check nested objects or arrays
+                if (isFormDirty(value)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false; // No dirty fields found
+};
+/**
+ * Extracts the root path of each error within the 'inner' property of the input object.
+ *
+ * @param data The input object containing error details.
+ * @returns An array of strings, where each string is the root path of an error.
+ */
+export const getErrorRootPaths = (data) => {
+    const rootPaths = [];
+    if (data && Array.isArray(data.inner)) {
+        data.inner.forEach((errorDetail) => {
+            if (errorDetail.path) {
+                // The root path is typically the first part before the dot
+                const rootPath = errorDetail.path.split(".")[0];
+                if (rootPath && !rootPaths.includes(rootPath)) {
+                    rootPaths.push(rootPath);
+                }
+            }
+        });
+    }
+    return rootPaths;
+};
+export const getRequiredUserInformation = (completeness, skip = []) => {
+    try {
+        UserCompletenessSchema.omit(skip).validateSync(completeness, {
+            abortEarly: false,
+        });
+        return [];
+    }
+    catch (error) {
+        return getErrorRootPaths(error);
+    }
+};
+export const getRequiredInformationByUser = (user, completeness) => {
+    if (user.experienceLevel === ExperienceLevel.Student ||
+        user.experienceLevel === ExperienceLevel.Entry) {
+        return getRequiredUserInformation(completeness, ["workExperiences"]);
+    }
+    else {
+        return getRequiredUserInformation(completeness);
+    }
+};

package/dist/esm/completeness/completeness.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=completeness.d.ts.map

package/dist/esm/completeness/completeness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completeness.d.ts","sourceRoot":"","sources":["../../../src/completeness/completeness.ts"],"names":[],"mappings":""}

package/dist/esm/completeness/completeness.js

@@ -0,0 +1,118 @@
+const extractFields = (schema, prefix = "", includeOptionals = false) => {
+    if (!schema?.fields)
+        return [];
+    const schemaFields = schema.fields;
+    let extractedFields = [];
+    const processField = (key, fieldSchema, currentPath) => {
+        const isRequired = !fieldSchema.spec?.optional;
+        const type = fieldSchema.type;
+        const innerType = fieldSchema.innerType?.type;
+        if (!isRequired && !includeOptionals)
+            return;
+        if (type === "array") {
+            const minItems = fieldSchema.tests?.find((t) => t.OPTIONS?.name === "min")?.OPTIONS
+                ?.params?.min || 0;
+            const itemSchema = fieldSchema.innerType;
+            // Handle required array items
+            for (let i = 0; i < minItems; i++) {
+                const indexPath = `${currentPath}.${i}`;
+                const itemFields = extractFields(itemSchema, indexPath, includeOptionals);
+                extractedFields.push(...itemFields);
+                if (itemFields.length === 0) {
+                    extractedFields.push({ key: indexPath, required: true });
+                }
+            }
+            // Handle optional array items
+            if (includeOptionals) {
+                const optionalFields = extractFields(itemSchema, currentPath, includeOptionals).map((f) => ({ ...f, key: `${f.key}[]`, required: false }));
+                extractedFields.push(...optionalFields);
+            }
+        }
+        else if (type === "object" || innerType === "object") {
+            const targetSchema = type === "object" ? fieldSchema : fieldSchema.innerType;
+            const nestedFields = extractFields(targetSchema, currentPath, includeOptionals);
+            extractedFields.push(...nestedFields);
+        }
+        else {
+            extractedFields.push({ key: currentPath, required: isRequired });
+        }
+    };
+    for (const key in schemaFields) {
+        const fieldSchema = schemaFields[key];
+        if (!fieldSchema)
+            continue;
+        const currentPath = prefix ? `${prefix}.${key}` : key;
+        processField(key, fieldSchema, currentPath);
+    }
+    return extractedFields;
+};
+export {};
+// const getValueByPath = (data: any, path: string) => {
+//   const parts = path.replace("[]", "").split(".");
+//   return parts.reduce((acc, part) => {
+//     if (acc === undefined || acc === null) return undefined;
+//     const match = part.match(/^(\d+)$/);
+//     if (match && match[1]) {
+//       const index = parseInt(match[1]);
+//       return Array.isArray(acc) ? acc[index] : undefined;
+//     }
+//     return acc[part];
+//   }, data);
+// };
+// export const getCompletenessScore = <T>(
+//   schema: any,
+//   data: T | T[],
+//   options: CompletenessOptions = { includeOptionals: false }
+// ): CompletenessScore => {
+//   const { includeOptionals = false, emptyArrayScore } = options;
+//   if (Array.isArray(data)) {
+//     if (data.length === 0) {
+//       return {
+//         score: emptyArrayScore === "perfect" ? 100 : 0,
+//         completedSteps: 0,
+//         totalSteps: 0,
+//         children: [],
+//       };
+//     }
+//     const children = data.map((item) =>
+//       getCompletenessScore(schema, item, options)
+//     );
+//     const contentScore =
+//       children.reduce((sum, child) => sum + child.score, 0) / children.length;
+//     return {
+//       score: Math.round(contentScore),
+//       completedSteps: children.reduce((sum, c) => sum + c.completedSteps, 0),
+//       totalSteps: children.reduce((sum, c) => sum + c.totalSteps, 0),
+//       children,
+//     };
+//   }
+//   const fields = extractFields(schema, "", includeOptionals);
+//   const requiredFields = fields.filter((f) => f.required);
+//   const totalSteps = includeOptionals ? fields.length : requiredFields.length;
+//   let completedSteps = 0;
+//   const meta = {
+//     steps: fields.map((f) => f.key),
+//     completed: [] as string[],
+//     incomplete: [] as string[],
+//   };
+//   fields.forEach(({ key, required }) => {
+//     const value = getValueByPath(data, key);
+//     const exists = value !== undefined && value !== null && value !== "";
+//     if (exists) {
+//       meta.completed.push(key);
+//       if (includeOptionals || required) completedSteps++;
+//     } else {
+//       if (includeOptionals || required) meta.incomplete.push(key);
+//     }
+//   });
+//   const score =
+//     totalSteps > 0 ? Math.floor((completedSteps / totalSteps) * 100) : 100;
+//   return {
+//     score,
+//     completedSteps: includeOptionals
+//       ? completedSteps
+//       : Math.min(completedSteps, requiredFields.length),
+//     totalSteps,
+//     meta,
+//   };
+// };

package/dist/esm/completeness/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./completeness";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/completeness/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/completeness/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/esm/completeness/index.js

@@ -0,0 +1 @@
+export * from "./completeness";

package/dist/esm/date/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/date/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/date/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/dist/esm/date/index.js

@@ -0,0 +1 @@
+export * from "./utils";

package/dist/esm/date/utils.d.ts

@@ -0,0 +1,14 @@
+import { DateRangeOption } from "@thejob/schema";
+import dayjs, { Dayjs } from "dayjs";
+export declare const toDayJS: ({ date, dateFormat, strict, utc, }?: {
+    date?: string | Dayjs;
+    dateFormat?: string;
+    strict?: boolean;
+    utc?: boolean;
+}) => dayjs.Dayjs;
+export declare const dateAgo: (value: number | string | Date) => string;
+export declare const dateRangeOptionToDateRange: (option: DateRangeOption) => {
+    startDate: string | undefined;
+    endDate: string | undefined;
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/date/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/date/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAoB,MAAM,gBAAgB,CAAC;AACnE,OAAO,KAAK,EAAE,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAQrC,eAAO,MAAM,OAAO,GAAI,qCAKrB;IACD,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,OAAO,CAAC;CACV,gBASL,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,OAAO,MAAM,GAAG,MAAM,GAAG,IAAI,WAEpD,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,QAAQ,eAAe;;;CA4CjE,CAAC"}

package/dist/esm/date/utils.js

@@ -0,0 +1,61 @@
+import { DateRangeOption, SystemDateFormat } from "@thejob/schema";
+import dayjs from "dayjs";
+import localizedFormat from "dayjs/plugin/localizedFormat";
+import relativeTime from "dayjs/plugin/relativeTime";
+import customParseFormat from "dayjs/plugin/customParseFormat";
+dayjs.extend(relativeTime);
+dayjs.extend(localizedFormat);
+dayjs.extend(customParseFormat);
+export const toDayJS = ({ date, dateFormat = SystemDateFormat, strict = false, utc = false, } = {}) => {
+    return dayjs(date, {
+        utc,
+        format: dateFormat,
+    }, strict);
+};
+export const dateAgo = (value) => {
+    return dayjs(value).fromNow();
+};
+export const dateRangeOptionToDateRange = (option) => {
+    const today = toDayJS({ utc: true });
+    let dateRange = {
+        startDate: undefined,
+        endDate: undefined,
+    };
+    switch (option) {
+        case DateRangeOption.LastMonth:
+            dateRange = {
+                startDate: today.subtract(1, "month"), //.startOf("month"),
+                endDate: today,
+            };
+            break;
+        case DateRangeOption.LastWeek:
+            dateRange = {
+                startDate: today.subtract(1, "week"), //.startOf("week"),
+                endDate: today, //.endOf("week"),
+            };
+            break;
+        case DateRangeOption.Last_3_Days:
+            dateRange = {
+                startDate: today.subtract(3, "days"),
+                endDate: today,
+            };
+            break;
+        case DateRangeOption.Last_24_Hours:
+            dateRange = {
+                startDate: today.subtract(24, "hours"),
+                endDate: today,
+            };
+            break;
+        case DateRangeOption.Any:
+        default:
+            dateRange = {
+                startDate: undefined,
+                endDate: undefined,
+            };
+            break;
+    }
+    return {
+        startDate: dateRange.startDate?.format(SystemDateFormat),
+        endDate: dateRange.endDate?.format(SystemDateFormat),
+    };
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./common";
+export * from "./completeness";
+export * from "./user";
+export * from "./date";
+export * from "./job";
+export * from "./job-application";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,mBAAmB,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+export * from "./common";
+export * from "./completeness";
+export * from "./user";
+export * from "./date";
+export * from "./job";
+export * from "./job-application";

package/dist/esm/job/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/job/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/job/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/dist/esm/job/index.js

@@ -0,0 +1 @@
+export * from "./utils";

package/dist/esm/job/utils.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/job/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/job/utils.ts"],"names":[],"mappings":""}

package/dist/esm/job/utils.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/job-application/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/job-application/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/job-application/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC"}

package/dist/esm/job-application/index.js

@@ -0,0 +1 @@
+export * from "./utils";

package/dist/esm/job-application/utils.d.ts

@@ -0,0 +1,3 @@
+import { JobApplicationScore } from "@thejob/schema";
+export declare const jobApplicationScoreToLabel: (score: JobApplicationScore) => "Exceptional" | "Qualified" | "Potential" | "Not Recommended" | "Unknown";
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/job-application/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/job-application/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAErD,eAAO,MAAM,0BAA0B,GAAI,OAAO,mBAAmB,8EAapE,CAAC"}