@inploi/plugin-job-search 0.23.6 → 0.23.7

package/dist/job-search.api.d.ts

@@ -2,8 +2,9 @@ import { ApiClient, Logger } from '@inploi/sdk';
 import { SWRResponse } from 'swr';
 import { Input, Output } from 'valibot';
 import { FilterValue } from './components/filter';
+import { TFunction } from './lib/translation.terms';
 
-declare const JobSearchResponseSchema: import('valibot').SchemaWithTransform<import('valibot').ObjectSchema<{
+declare const getJobSearchResponseSchema: (t: TFunction) => import('valibot').SchemaWithTransform<import('valibot').ObjectSchema<{
     data: import('valibot').ArraySchema<import('valibot').SchemaWithTransform<import('valibot').ObjectSchema<{
         id: import('valibot').NumberSchema<number>;
         company_name: import('valibot').StringSchema<string>;
@@ -273,8 +274,8 @@ declare const JobSearchResponseSchema: import('valibot').SchemaWithTransform<imp
         };
     }[];
 }>;
-export type JobSearchResponsePayloadInput = Input<typeof JobSearchResponseSchema>;
-export type JobSearchResponsePayloadOutput = Output<typeof JobSearchResponseSchema>;
+export type JobSearchResponsePayloadInput = Input<ReturnType<typeof getJobSearchResponseSchema>>;
+export type JobSearchResponsePayloadOutput = Output<ReturnType<typeof getJobSearchResponseSchema>>;
 export declare const getFilterValue: (filterValue: string | string[] | undefined) => string | string[] | null;
 export declare const filtersToPayload: (filters: Record<string, FilterValue | undefined>) => Record<string, string | string[] | null>;
 export declare const getAvailableFilters: ({ apiClient, filters, keyword, logger, signal, }: {
@@ -291,13 +292,14 @@ export declare const getAvailableFilters: ({ apiClient, filters, keyword, logger
     }[];
 }>;
 export type GetAvailableFiltersResponse = Awaited<ReturnType<typeof getAvailableFilters>>;
-export declare const getJobSearchResults: ({ apiClient, logger, signal, filters, keyword, page, }: {
+export declare const getJobSearchResults: ({ apiClient, logger, signal, filters, keyword, page, t, }: {
     apiClient: ApiClient;
     logger: Logger;
     signal?: AbortSignal;
     filters: Record<string, FilterValue | undefined>;
     keyword?: string;
     page?: number;
+    t: TFunction;
 }) => Promise<{
     pagination: {
         total: number;

package/dist/job-search.d.ts

@@ -2,6 +2,7 @@ import { TargetedEvent } from 'preact/compat';
 import { getJobSearchResults } from './job-search.api.ts';
 import { FilterValue } from './components/filter.tsx';
 import { IconName } from './components/icon.tsx';
+import { JobSearchTranslationTerms } from './lib/translation.terms.ts';
 
 type FontSettings = {
     fontFamily: string;
@@ -138,6 +139,8 @@ export type JobSearchPluginParams = {
     enableJobAlerts?: boolean;
     /** Enables searching for jobs by keyword */
     enableKeywordSearch?: boolean;
+    /** Translation terms */
+    terms?: JobSearchTranslationTerms;
 };
 export interface PrerenderJobSearchPluginParams extends JobSearchPluginParams {
     /** If true, the data needed to display the first page of results

package/dist/job-search.schemas.d.ts

@@ -1,4 +1,5 @@
 import { Output } from 'valibot';
+import { TFunction } from './lib/translation.terms';
 
 export declare const AvailablePropertiesSchema: import('valibot').RecordSchema<import('valibot').StringSchema<string>, import('valibot').ArraySchema<import('valibot').ObjectSchema<{
     label: import('valibot').StringSchema<string>;
@@ -91,7 +92,7 @@ export declare const JobPayloadSchema: import('valibot').ObjectSchema<{
     town?: string | undefined;
 }>;
 export type JobPayloadSchema = Output<typeof JobPayloadSchema>;
-export declare const JobSchema: import('valibot').SchemaWithTransform<import('valibot').ObjectSchema<{
+export declare const getJobSchema: (t: TFunction) => import('valibot').SchemaWithTransform<import('valibot').ObjectSchema<{
     id: import('valibot').NumberSchema<number>;
     company_name: import('valibot').StringSchema<string>;
     company_logo: import('valibot').NullableSchema<import('valibot').OptionalSchema<import('valibot').StringSchema<string>, undefined, string | undefined>, undefined, string | undefined>;
@@ -194,4 +195,4 @@ export declare const JobSchema: import('valibot').SchemaWithTransform<import('va
         town?: string | undefined;
     };
 }>;
-export type JobSchema = Output<typeof JobSchema>;
+export type JobSchema = Output<ReturnType<typeof getJobSchema>>;

package/dist/lib/cache-key.d.ts

@@ -0,0 +1,7 @@
+import { FilterValue } from '../components/filter';
+
+export declare const cacheKey: (value: {
+    filter: Record<string, FilterValue | undefined>;
+    baseKey: string;
+    keyword: string | undefined;
+}) => string;

package/dist/lib/cache-key.test.d.ts

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

package/dist/lib/currency.d.ts

@@ -0,0 +1,10 @@
+import { JobPayloadSchema } from '../job-search.schemas';
+import { TFunction } from './translation.terms';
+
+export declare const getSalaryAsText: (params: {
+    salary: Pick<JobPayloadSchema, 'pay' | 'pay_min' | 'pay_mask' | 'pay_max' | 'pay_type' | 'pay_currency' | 'pay_display'>;
+    config: {
+        locales: string | string[] | undefined;
+    };
+    t: TFunction;
+}) => string | undefined;

package/dist/lib/currency.test.d.ts

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

package/dist/lib/datetime.d.ts

@@ -0,0 +1,11 @@
+import { TFunction } from './translation.terms';
+
+type Params = {
+    from?: Date;
+    to: string | number | Date;
+    formatter?: Intl.RelativeTimeFormat;
+    t: TFunction;
+};
+/** From a date, calculates the relative time difference from now */
+export declare const getRelativeTimeDifference: ({ from, to, formatter, t }: Params) => string;
+export {};

package/dist/lib/deep-set.d.ts

@@ -0,0 +1,8 @@
+type NestedObject = {
+    [key: string]: NestedObject | any;
+};
+/** Converts an object with dot separated keys to a nested object
+ *  @example {"a.b.c": 1} -> {a: {b: {c: 1}}}
+ */
+export declare function convertObject<T extends Record<string, any>>(input: T, transformValue?: (value: any) => any): NestedObject;
+export {};

package/dist/lib/deep-set.test.d.ts

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

package/dist/lib/hooks.d.ts

@@ -0,0 +1,8 @@
+export declare const useMediaQuery: (query: string) => boolean;
+type ViewTrackingOptions = {
+    minViewTime?: number;
+    visibilityThreshold?: number | number[];
+    onView: () => void;
+};
+export declare const useViewTracking: (elementRef: React.RefObject<HTMLElement>, { minViewTime, visibilityThreshold, onView }: ViewTrackingOptions) => void;
+export {};

package/dist/lib/match.d.ts

@@ -0,0 +1,35 @@
+/** Simple object pattern matching. A smaller, shittier version of ts-pattern */
+export declare const match: <M extends object>(subject: M) => {
+    with: <const P extends Partial<M>, Fn extends (pattern: M & P extends infer T ? { [k in keyof T]: (M & P)[k]; } : never) => any>(pattern: P, fn: Fn) => {
+        with: <const P_1 extends Partial<Exclude<M, P>>, Fn_1 extends (pattern: Exclude<M, P> & P_1 extends infer T_1 ? { [k_1 in keyof T_1]: (Exclude<M, P> & P_1)[k_1]; } : never) => any>(pattern: P_1, fn: Fn_1) => {
+            with: <const P_2 extends Partial<Exclude<Exclude<M, P>, P_1>>, Fn_2 extends (pattern: Exclude<Exclude<M, P>, P_1> & P_2 extends infer T_2 ? { [k_2 in keyof T_2]: (Exclude<Exclude<M, P>, P_1> & P_2)[k_2]; } : never) => any>(pattern: P_2, fn: Fn_2) => {
+                with: <const P_3 extends Partial<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>>, Fn_3 extends (pattern: Exclude<Exclude<Exclude<M, P>, P_1>, P_2> & P_3 extends infer T_3 ? { [k_3 in keyof T_3]: (Exclude<Exclude<Exclude<M, P>, P_1>, P_2> & P_3)[k_3]; } : never) => any>(pattern: P_3, fn: Fn_3) => {
+                    with: <const P_4 extends Partial<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>>, Fn_4 extends (pattern: Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3> & P_4 extends infer T_4 ? { [k_4 in keyof T_4]: (Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3> & P_4)[k_4]; } : never) => any>(pattern: P_4, fn: Fn_4) => {
+                        with: <const P_5 extends Partial<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>>, Fn_5 extends (pattern: Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4> & P_5 extends infer T_5 ? { [k_5 in keyof T_5]: (Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4> & P_5)[k_5]; } : never) => any>(pattern: P_5, fn: Fn_5) => {
+                            with: <const P_6 extends Partial<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>>, Fn_6 extends (pattern: Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5> & P_6 extends infer T_6 ? { [k_6 in keyof T_6]: (Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5> & P_6)[k_6]; } : never) => any>(pattern: P_6, fn: Fn_6) => {
+                                with: <const P_7 extends Partial<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>>, Fn_7 extends (pattern: Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6> & P_7 extends infer T_7 ? { [k_7 in keyof T_7]: (Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6> & P_7)[k_7]; } : never) => any>(pattern: P_7, fn: Fn_7) => {
+                                    with: <const P_8 extends Partial<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7>>, Fn_8 extends (pattern: Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7> & P_8 extends infer T_8 ? { [k_8 in keyof T_8]: (Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7> & P_8)[k_8]; } : never) => any>(pattern: P_8, fn: Fn_8) => {
+                                        with: <const P_9 extends Partial<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7>, P_8>>, Fn_9 extends (pattern: Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7>, P_8> & P_9 extends infer T_9 ? { [k_9 in keyof T_9]: (Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7>, P_8> & P_9)[k_9]; } : never) => any>(pattern: P_9, fn: Fn_9) => {
+                                            with: <const P_10 extends Partial<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7>, P_8>, P_9>>, Fn_10 extends (pattern: Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7>, P_8>, P_9> & P_10 extends infer T_10 ? { [k_10 in keyof T_10]: (Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7>, P_8>, P_9> & P_10)[k_10]; } : never) => any>(pattern: P_10, fn: Fn_10) => any;
+                                            otherwise: <O extends (subject: Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7>, P_8>, P_9>) => any = () => never>(fallback?: O | undefined) => ReturnType<Fn> | ReturnType<Fn_1> | ReturnType<Fn_2> | ReturnType<Fn_3> | ReturnType<Fn_4> | ReturnType<Fn_5> | ReturnType<Fn_6> | ReturnType<Fn_7> | ReturnType<Fn_8> | ReturnType<Fn_9> | ReturnType<O>;
+                                        };
+                                        otherwise: <O_1 extends (subject: Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7>, P_8>) => any = () => never>(fallback?: O_1 | undefined) => ReturnType<Fn> | ReturnType<Fn_1> | ReturnType<Fn_2> | ReturnType<Fn_3> | ReturnType<Fn_4> | ReturnType<Fn_5> | ReturnType<Fn_6> | ReturnType<Fn_7> | ReturnType<Fn_8> | ReturnType<O_1>;
+                                    };
+                                    otherwise: <O_2 extends (subject: Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>, P_7>) => any = () => never>(fallback?: O_2 | undefined) => ReturnType<Fn> | ReturnType<Fn_1> | ReturnType<Fn_2> | ReturnType<Fn_3> | ReturnType<Fn_4> | ReturnType<Fn_5> | ReturnType<Fn_6> | ReturnType<Fn_7> | ReturnType<O_2>;
+                                };
+                                otherwise: <O_3 extends (subject: Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>, P_6>) => any = () => never>(fallback?: O_3 | undefined) => ReturnType<Fn> | ReturnType<Fn_1> | ReturnType<Fn_2> | ReturnType<Fn_3> | ReturnType<Fn_4> | ReturnType<Fn_5> | ReturnType<Fn_6> | ReturnType<O_3>;
+                            };
+                            otherwise: <O_4 extends (subject: Exclude<Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>, P_5>) => any = () => never>(fallback?: O_4 | undefined) => ReturnType<Fn> | ReturnType<Fn_1> | ReturnType<Fn_2> | ReturnType<Fn_3> | ReturnType<Fn_4> | ReturnType<Fn_5> | ReturnType<O_4>;
+                        };
+                        otherwise: <O_5 extends (subject: Exclude<Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>, P_4>) => any = () => never>(fallback?: O_5 | undefined) => ReturnType<Fn> | ReturnType<Fn_1> | ReturnType<Fn_2> | ReturnType<Fn_3> | ReturnType<Fn_4> | ReturnType<O_5>;
+                    };
+                    otherwise: <O_6 extends (subject: Exclude<Exclude<Exclude<Exclude<M, P>, P_1>, P_2>, P_3>) => any = () => never>(fallback?: O_6 | undefined) => ReturnType<Fn> | ReturnType<Fn_1> | ReturnType<Fn_2> | ReturnType<Fn_3> | ReturnType<O_6>;
+                };
+                otherwise: <O_7 extends (subject: Exclude<Exclude<Exclude<M, P>, P_1>, P_2>) => any = () => never>(fallback?: O_7 | undefined) => ReturnType<Fn> | ReturnType<Fn_1> | ReturnType<Fn_2> | ReturnType<O_7>;
+            };
+            otherwise: <O_8 extends (subject: Exclude<Exclude<M, P>, P_1>) => any = () => never>(fallback?: O_8 | undefined) => ReturnType<Fn> | ReturnType<Fn_1> | ReturnType<O_8>;
+        };
+        otherwise: <O_9 extends (subject: Exclude<M, P>) => any = () => never>(fallback?: O_9 | undefined) => ReturnType<Fn> | ReturnType<O_9>;
+    };
+    otherwise: <O_10 extends (subject: M) => any = () => never>(fallback?: O_10 | undefined) => ReturnType<O_10>;
+};

package/dist/lib/match.test.d.ts

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

package/dist/lib/translation.d.ts

@@ -0,0 +1,44 @@
+import { ComponentChildren } from 'preact';
+
+type StringContains<Haystack extends string, Needle extends string> = Haystack extends `${string}${Needle}${string}` ? true : false;
+type HintedString<KnownValues> = (string & {}) | KnownValues;
+type TranslationWithPlurals = {
+    one: string;
+    other: string;
+};
+export type Terms = Record<string, string | TranslationWithPlurals>;
+export type TranslationDict<TTerms extends Terms> = {
+    [K in keyof TTerms]: TTerms[K] extends TranslationWithPlurals ? {
+        [J in keyof TTerms[K]]: HintedString<TTerms[K][J]>;
+    } : HintedString<TTerms[K]>;
+};
+export declare const createTranslation: <const TTerms extends Terms>(defaultTerms: TTerms) => {
+    TranslationProvider: ({ terms, children, }: {
+        terms?: Partial<TranslationDict<TTerms>>;
+        children: ComponentChildren;
+    }) => import("preact").JSX.Element;
+    useTranslation: <T extends TTerms = TTerms>() => {
+        t: {
+            <T_1 extends { [K in keyof T]: T[K] extends TranslationWithPlurals ? K : StringContains<T[K] & string, "{{count}}"> extends true ? K : never; }[keyof T]>(key: T_1, options: {
+                count: number;
+            }): string;
+            <T_2 extends Exclude<keyof T, { [K in keyof T]: T[K] extends TranslationWithPlurals ? K : StringContains<T[K] & string, "{{count}}"> extends true ? K : never; }[keyof T]>>(key: T_2): string;
+        };
+    };
+    createTFunction: <T_3 extends TTerms = TTerms>(overrides: Partial<TranslationDict<TTerms>>) => {
+        <T_4 extends { [K_1 in keyof T_3]: T_3[K_1] extends TranslationWithPlurals ? K_1 : StringContains<T_3[K_1] & string, "{{count}}"> extends true ? K_1 : never; }[keyof T_3]>(key: T_4, options: {
+            count: number;
+        }): string;
+        <T_5 extends Exclude<keyof T_3, { [K_1 in keyof T_3]: T_3[K_1] extends TranslationWithPlurals ? K_1 : StringContains<T_3[K_1] & string, "{{count}}"> extends true ? K_1 : never; }[keyof T_3]>>(key: T_5): string;
+    };
+};
+export declare const createTranslateFunction: <const TTerms extends Terms>({ terms, overrides, }: {
+    terms: TTerms;
+    overrides?: Partial<TranslationDict<TTerms>>;
+}) => {
+    <T extends { [K in keyof TTerms]: TTerms[K] extends TranslationWithPlurals ? K : StringContains<TTerms[K] & string, "{{count}}"> extends true ? K : never; }[keyof TTerms]>(key: T, options: {
+        count: number;
+    }): string;
+    <T_1 extends Exclude<keyof TTerms, { [K in keyof TTerms]: TTerms[K] extends TranslationWithPlurals ? K : StringContains<TTerms[K] & string, "{{count}}"> extends true ? K : never; }[keyof TTerms]>>(key: T_1): string;
+};
+export {};

package/dist/lib/translation.terms.d.ts

@@ -0,0 +1,216 @@
+export declare const TranslationProvider: ({ terms, children, }: {
+    terms?: Partial<import('./translation').TranslationDict<{
+        readonly type_to_search_jobs: "Type to search jobs";
+        readonly type_to_search: "Type to search";
+        readonly jobs_found: {
+            readonly one: "{{count}} job found";
+            readonly other: "{{count}} jobs found";
+        };
+        readonly no_jobs_found: "No jobs found";
+        readonly no_jobs_found_description: "We could not find any jobs matching your filtering criteria.";
+        readonly jobs_loading_error: "We’re having trouble loading available jobs.";
+        readonly filters_loading_error: "We’re having trouble loading available filters.";
+        readonly no_filter_options_available: "No filter options available.";
+        readonly clear: "Clear";
+        readonly selected: "selected";
+        readonly done: "Done";
+        readonly skip: "Skip";
+        readonly new: "NEW";
+        readonly posted: "Posted";
+        readonly retry: "Retry";
+        readonly widget_unavailable: "Sorry, this widget is unavailable at the moment.";
+        readonly load_more_count: "Load {{count}} more";
+        readonly of_remaining_count: "of {{count}} remaining";
+        readonly create_alert: "Create alert";
+        readonly alert_header_text: "You will be alerted for new jobs matching the filters currently set";
+        readonly today: "today";
+        readonly over_30_days_ago: "over 30 days ago";
+        readonly in_over_30_days: "in over 30 days";
+        readonly up_to: "Up to";
+        readonly from: "From";
+        readonly invalid_salary: "Invalid salary";
+        readonly competitive: "Competitive";
+    }>> | undefined;
+    children: import('preact').ComponentChildren;
+}) => import("preact").JSX.Element, useTranslation: <T extends {
+    readonly type_to_search_jobs: "Type to search jobs";
+    readonly type_to_search: "Type to search";
+    readonly jobs_found: {
+        readonly one: "{{count}} job found";
+        readonly other: "{{count}} jobs found";
+    };
+    readonly no_jobs_found: "No jobs found";
+    readonly no_jobs_found_description: "We could not find any jobs matching your filtering criteria.";
+    readonly jobs_loading_error: "We’re having trouble loading available jobs.";
+    readonly filters_loading_error: "We’re having trouble loading available filters.";
+    readonly no_filter_options_available: "No filter options available.";
+    readonly clear: "Clear";
+    readonly selected: "selected";
+    readonly done: "Done";
+    readonly skip: "Skip";
+    readonly new: "NEW";
+    readonly posted: "Posted";
+    readonly retry: "Retry";
+    readonly widget_unavailable: "Sorry, this widget is unavailable at the moment.";
+    readonly load_more_count: "Load {{count}} more";
+    readonly of_remaining_count: "of {{count}} remaining";
+    readonly create_alert: "Create alert";
+    readonly alert_header_text: "You will be alerted for new jobs matching the filters currently set";
+    readonly today: "today";
+    readonly over_30_days_ago: "over 30 days ago";
+    readonly in_over_30_days: "in over 30 days";
+    readonly up_to: "Up to";
+    readonly from: "From";
+    readonly invalid_salary: "Invalid salary";
+    readonly competitive: "Competitive";
+} = {
+    readonly type_to_search_jobs: "Type to search jobs";
+    readonly type_to_search: "Type to search";
+    readonly jobs_found: {
+        readonly one: "{{count}} job found";
+        readonly other: "{{count}} jobs found";
+    };
+    readonly no_jobs_found: "No jobs found";
+    readonly no_jobs_found_description: "We could not find any jobs matching your filtering criteria.";
+    readonly jobs_loading_error: "We’re having trouble loading available jobs.";
+    readonly filters_loading_error: "We’re having trouble loading available filters.";
+    readonly no_filter_options_available: "No filter options available.";
+    readonly clear: "Clear";
+    readonly selected: "selected";
+    readonly done: "Done";
+    readonly skip: "Skip";
+    readonly new: "NEW";
+    readonly posted: "Posted";
+    readonly retry: "Retry";
+    readonly widget_unavailable: "Sorry, this widget is unavailable at the moment.";
+    readonly load_more_count: "Load {{count}} more";
+    readonly of_remaining_count: "of {{count}} remaining";
+    readonly create_alert: "Create alert";
+    readonly alert_header_text: "You will be alerted for new jobs matching the filters currently set";
+    readonly today: "today";
+    readonly over_30_days_ago: "over 30 days ago";
+    readonly in_over_30_days: "in over 30 days";
+    readonly up_to: "Up to";
+    readonly from: "From";
+    readonly invalid_salary: "Invalid salary";
+    readonly competitive: "Competitive";
+}>() => {
+    t: {
+        <T_2 extends { [K in keyof T]: T[K] extends {
+            one: string;
+            other: string;
+        } ? K : (T[K] & string extends infer T_1 ? T_1 extends T[K] & string ? T_1 extends `${string}{{count}}${string}` ? true : false : never : never) extends true ? K : never; }[keyof T]>(key: T_2, options: {
+            count: number;
+        }): string;
+        <T_3 extends Exclude<keyof T, { [K in keyof T]: T[K] extends {
+            one: string;
+            other: string;
+        } ? K : (T[K] & string extends infer T_1 ? T_1 extends T[K] & string ? T_1 extends `${string}{{count}}${string}` ? true : false : never : never) extends true ? K : never; }[keyof T]>>(key: T_3): string;
+    };
+}, createTFunction: <T extends {
+    readonly type_to_search_jobs: "Type to search jobs";
+    readonly type_to_search: "Type to search";
+    readonly jobs_found: {
+        readonly one: "{{count}} job found";
+        readonly other: "{{count}} jobs found";
+    };
+    readonly no_jobs_found: "No jobs found";
+    readonly no_jobs_found_description: "We could not find any jobs matching your filtering criteria.";
+    readonly jobs_loading_error: "We’re having trouble loading available jobs.";
+    readonly filters_loading_error: "We’re having trouble loading available filters.";
+    readonly no_filter_options_available: "No filter options available.";
+    readonly clear: "Clear";
+    readonly selected: "selected";
+    readonly done: "Done";
+    readonly skip: "Skip";
+    readonly new: "NEW";
+    readonly posted: "Posted";
+    readonly retry: "Retry";
+    readonly widget_unavailable: "Sorry, this widget is unavailable at the moment.";
+    readonly load_more_count: "Load {{count}} more";
+    readonly of_remaining_count: "of {{count}} remaining";
+    readonly create_alert: "Create alert";
+    readonly alert_header_text: "You will be alerted for new jobs matching the filters currently set";
+    readonly today: "today";
+    readonly over_30_days_ago: "over 30 days ago";
+    readonly in_over_30_days: "in over 30 days";
+    readonly up_to: "Up to";
+    readonly from: "From";
+    readonly invalid_salary: "Invalid salary";
+    readonly competitive: "Competitive";
+} = {
+    readonly type_to_search_jobs: "Type to search jobs";
+    readonly type_to_search: "Type to search";
+    readonly jobs_found: {
+        readonly one: "{{count}} job found";
+        readonly other: "{{count}} jobs found";
+    };
+    readonly no_jobs_found: "No jobs found";
+    readonly no_jobs_found_description: "We could not find any jobs matching your filtering criteria.";
+    readonly jobs_loading_error: "We’re having trouble loading available jobs.";
+    readonly filters_loading_error: "We’re having trouble loading available filters.";
+    readonly no_filter_options_available: "No filter options available.";
+    readonly clear: "Clear";
+    readonly selected: "selected";
+    readonly done: "Done";
+    readonly skip: "Skip";
+    readonly new: "NEW";
+    readonly posted: "Posted";
+    readonly retry: "Retry";
+    readonly widget_unavailable: "Sorry, this widget is unavailable at the moment.";
+    readonly load_more_count: "Load {{count}} more";
+    readonly of_remaining_count: "of {{count}} remaining";
+    readonly create_alert: "Create alert";
+    readonly alert_header_text: "You will be alerted for new jobs matching the filters currently set";
+    readonly today: "today";
+    readonly over_30_days_ago: "over 30 days ago";
+    readonly in_over_30_days: "in over 30 days";
+    readonly up_to: "Up to";
+    readonly from: "From";
+    readonly invalid_salary: "Invalid salary";
+    readonly competitive: "Competitive";
+}>(overrides: Partial<import('./translation').TranslationDict<{
+    readonly type_to_search_jobs: "Type to search jobs";
+    readonly type_to_search: "Type to search";
+    readonly jobs_found: {
+        readonly one: "{{count}} job found";
+        readonly other: "{{count}} jobs found";
+    };
+    readonly no_jobs_found: "No jobs found";
+    readonly no_jobs_found_description: "We could not find any jobs matching your filtering criteria.";
+    readonly jobs_loading_error: "We’re having trouble loading available jobs.";
+    readonly filters_loading_error: "We’re having trouble loading available filters.";
+    readonly no_filter_options_available: "No filter options available.";
+    readonly clear: "Clear";
+    readonly selected: "selected";
+    readonly done: "Done";
+    readonly skip: "Skip";
+    readonly new: "NEW";
+    readonly posted: "Posted";
+    readonly retry: "Retry";
+    readonly widget_unavailable: "Sorry, this widget is unavailable at the moment.";
+    readonly load_more_count: "Load {{count}} more";
+    readonly of_remaining_count: "of {{count}} remaining";
+    readonly create_alert: "Create alert";
+    readonly alert_header_text: "You will be alerted for new jobs matching the filters currently set";
+    readonly today: "today";
+    readonly over_30_days_ago: "over 30 days ago";
+    readonly in_over_30_days: "in over 30 days";
+    readonly up_to: "Up to";
+    readonly from: "From";
+    readonly invalid_salary: "Invalid salary";
+    readonly competitive: "Competitive";
+}>>) => {
+    <T_2 extends { [K in keyof T]: T[K] extends {
+        one: string;
+        other: string;
+    } ? K : (T[K] & string extends infer T_1 ? T_1 extends T[K] & string ? T_1 extends `${string}{{count}}${string}` ? true : false : never : never) extends true ? K : never; }[keyof T]>(key: T_2, options: {
+        count: number;
+    }): string;
+    <T_4 extends Exclude<keyof T, { [K in keyof T]: T[K] extends {
+        one: string;
+        other: string;
+    } ? K : (T[K] & string extends infer T_3 ? T_3 extends T[K] & string ? T_3 extends `${string}{{count}}${string}` ? true : false : never : never) extends true ? K : never; }[keyof T]>>(key: T_4): string;
+};
+export type TFunction = ReturnType<typeof useTranslation>['t'];
+export type JobSearchTranslationTerms = Parameters<typeof TranslationProvider>[0]['terms'];

package/dist/lib/translation.test.d.ts

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

package/dist/lib/type-utils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * A type-safe way to get the keys and values of an object..
+ */
+export declare const objectEntries: <TObj extends object>(obj: TObj) => [keyof TObj, TObj[keyof TObj]][];
+export type NonEmptyString<T extends string> = T extends '' ? never : T;
+export type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * Constructs a string type with type hints for known values.
+ */
+export type HintedString<KnownValues extends string> = (string & {}) | KnownValues;
+export type Flatten<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+/** Allows you to get a type from a union of types.
+ * @example Select<string | number, string> will return string. */
+export type Select<T, U extends T> = U;
+export type Maybe<T> = T | null | undefined;
+export type PartialReadonly<T> = T | Readonly<T>;
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type Jsonify<T> = IsAny<T> extends true ? any : T extends ({
+    toJSON(): infer U;
+}) ? U extends JsonValue ? U : unknown : T extends JsonPrimitive ? T : T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends Promise<unknown> ? EmptyObject : T extends Map<unknown, unknown> ? EmptyObject : T extends Set<unknown> ? EmptyObject : T extends TypedArray ? Record<string, number> : T extends NotJson ? never : T extends [] ? [] : T extends readonly [infer F, ...infer R] ? [NeverToNull<Jsonify<F>>, ...Jsonify<R>] : T extends readonly unknown[] ? NeverToNull<Jsonify<T[number]>>[] : T extends Record<keyof unknown, unknown> ? JsonifyObject<T> : unknown extends T ? unknown : never;
+type ValueIsNotJson<T> = T extends NotJson ? true : false;
+type IsNotJson<T> = {
+    [K in keyof T]-?: ValueIsNotJson<T[K]>;
+};
+type JsonifyValues<T> = {
+    [K in keyof T]: Jsonify<T[K]>;
+};
+type JsonifyObject<T extends Record<keyof unknown, unknown>> = {
+    [K in keyof T as unknown extends T[K] ? never : IsNotJson<T>[K] extends false ? K : never]: JsonifyValues<T>[K];
+} & {
+    [K in keyof T as unknown extends T[K] ? K : IsNotJson<T>[K] extends false ? never : IsNotJson<T>[K] extends true ? never : K]?: JsonifyValues<T>[K];
+};
+type JsonPrimitive = string | number | boolean | null;
+type JsonArray = JsonValue[] | readonly JsonValue[];
+type JsonObject = {
+    [K in string]: JsonValue;
+} & {
+    [K in string]?: JsonValue;
+};
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+type NotJson = undefined | symbol | AnyFunction;
+type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+type AnyFunction = (...args: any[]) => unknown;
+type NeverToNull<T> = [T] extends [never] ? null : T;
+declare const emptyObjectSymbol: unique symbol;
+export type EmptyObject = {
+    [emptyObjectSymbol]?: never;
+};
+type IsAny<T> = 0 extends 1 & T ? true : false;
+export {};

package/dist/lib/utils.d.ts

@@ -0,0 +1,4 @@
+import { FilterProperty } from '..';
+
+/** Reads from search params provided and adds to list of filters. */
+export declare const getStatefulPropertiesFromSearchParams: (properties: FilterProperty[], searchParams: URLSearchParams) => FilterProperty[];

package/dist/mocks/browser.d.ts

@@ -0,0 +1 @@
+export declare const worker: import('msw/browser').SetupWorker;

package/dist/mocks/handlers.d.ts

@@ -0,0 +1,15 @@
+export declare const availableFiltersHandler: {
+    withResults: import('msw').HttpHandler;
+    malformed: import('msw').HttpHandler;
+};
+export declare const jobSearchHandler: {
+    withResults: import('msw').HttpHandler;
+    noResults: import('msw').HttpHandler;
+    /** Returns an invalid payload with a 200 code.
+     *  E.g.: if the backend returns something incompatible with the frontend.
+     */
+    invalid_payload: import('msw').HttpHandler;
+    /** Returns a laravel-structured error */
+    exception: import('msw').HttpHandler;
+};
+export declare const browserHandlers: import('msw').HttpHandler[];