@omerlo/omerlo-webkit 0.0.4 → 0.0.6

package/dist/omerlo/reader/index.d.ts

@@ -1,3 +1,20 @@
 export * from './stores/user_session';
-export type * from './endpoints/oauth';
 export type * from './endpoints/accounts';
+export type * from './endpoints/categories';
+export type * from './endpoints/content-templates';
+export type * from './endpoints/contents';
+export type * from './endpoints/device';
+export type * from './endpoints/events';
+export type * from './endpoints/magazines';
+export type * from './endpoints/media';
+export type * from './endpoints/menu';
+export type * from './endpoints/notification';
+export type * from './endpoints/oauth';
+export type * from './endpoints/organizations';
+export type * from './endpoints/person';
+export type * from './endpoints/profileType';
+export type * from './endpoints/profiles';
+export type * from './endpoints/projects';
+export type * from './endpoints/visuals';
+export type * from './endpoints/webpage';
+export type * from './utils/response';

package/dist/omerlo/reader/index.js

@@ -1 +1,19 @@
+import { parseCategory } from './endpoints/categories';
+import { parseProfileBlock, parseProfileSummary } from './endpoints/profiles';
+import { parseContentBlockTemplate, parseContentTemplate } from './endpoints/content-templates';
+import { parseProfileTypeSummary } from './endpoints/profileType';
+import { registerAssocParser } from './utils/assocs';
+import { parseContentSummary } from './endpoints/contents';
+import { parseIssueBlockConfiguration, parseIssueType } from './endpoints/magazines';
 export * from './stores/user_session';
+registerAssocParser('categories', parseCategory);
+registerAssocParser('profiles', parseProfileSummary);
+registerAssocParser('content_templates', parseContentTemplate);
+registerAssocParser('profile_types', parseProfileTypeSummary);
+registerAssocParser('profile_block_types', parseProfileBlock);
+registerAssocParser('content_block_templates', parseContentBlockTemplate);
+registerAssocParser('contents', parseContentSummary);
+registerAssocParser('issue_types', parseIssueType);
+registerAssocParser('issue_block_configurations', parseIssueBlockConfiguration);
+// NOTE: This one is for retro compatibility with publisher public api v2
+registerAssocParser('templates', parseContentTemplate);

package/dist/omerlo/reader/server/email.d.ts

@@ -0,0 +1,12 @@
+export interface EmailParams {
+    context: 'platform' | 'media';
+    to: string;
+    subject: string;
+    body: string;
+}
+/**
+ * Send an email.
+ *
+ * Return `true` if the email has been sent. It could take a couple of minutes to be received.
+ */
+export declare function sendEmail(params: EmailParams): Promise<boolean>;

package/dist/omerlo/reader/server/email.js

@@ -0,0 +1,30 @@
+import { env } from '$env/dynamic/private';
+import { ApiError } from '../utils/api';
+import { getApplicationToken } from './utils';
+/**
+ * Send an email.
+ *
+ * Return `true` if the email has been sent. It could take a couple of minutes to be received.
+ */
+export async function sendEmail(params) {
+    const url = getOmerloEndpoint();
+    const accessToken = await getApplicationToken();
+    const headers = new Headers({
+        'x-omerlo-media-id': env.PRIVATE_OMERLO_MEDIA_ID,
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'text/html'
+    });
+    url.pathname = '/api/media/v1/mail/send';
+    url.searchParams.append('context', params.context);
+    url.searchParams.append('to', params.to);
+    url.searchParams.append('subject', params.subject);
+    const resp = await fetch(url, { method: 'POST', headers, body: params.body });
+    if (resp.ok) {
+        return Promise.resolve(true);
+    }
+    const payload = await resp.json();
+    throw new ApiError(resp.status, payload.error, resp.statusText);
+}
+function getOmerloEndpoint() {
+    return new URL(`${env.PRIVATE_OMERLO_PROTOCOL}://${env.PRIVATE_OMERLO_HOST}`);
+}

package/dist/omerlo/reader/server/hooks.d.ts

@@ -1,3 +1,3 @@
-import { type Handle } from "@sveltejs/kit";
+import { type Handle } from '@sveltejs/kit';
 export declare const proxyHook: Handle;
 export declare const handleUserToken: Handle;

package/dist/omerlo/reader/server/hooks.js

@@ -1,27 +1,26 @@
-import { error } from "@sveltejs/kit";
+import { error } from '@sveltejs/kit';
 import { env } from '$env/dynamic/private';
-import { ApiError } from "../utils/api";
-import { clearAuthorizationCookies, clearAuthorizationUsingHeader, getAccessTokenFromCookie, getApplicationToken, getRefreshTokenFromCookie, setAuthorizationCookies } from "./utils";
-import { refresh } from "./token";
+import { ApiError } from '../utils/api';
+import { clearAuthorizationCookies, clearAuthorizationUsingHeader, getAccessTokenFromCookie, getApplicationToken, getRefreshTokenFromCookie, setAuthorizationCookies } from './utils';
+import { refresh } from './token';
 // NOTE: inspired by https://sami.website/blog/sveltekit-api-reverse-proxy
 const handleApiProxy = async ({ event, ...tail }) => {
+    // NOTE: It's important to reset the port BEFORE settings the host because the host could contains the port
+    // Example: localhost:4000
+    event.url.port = '';
     event.url.host = env.PRIVATE_OMERLO_HOST;
     event.url.protocol = env.PRIVATE_OMERLO_PROTOCOL;
-    event.url.port = ''; // This to prevent custom posts when working with localhost
-    let accessToken = event.locals.accessToken;
-    if (!accessToken) {
-        accessToken = await getApplicationToken();
-    }
+    const accessToken = event.locals.accessToken ?? (await getApplicationToken());
     const body = event.request.body;
     const method = event.request.method;
-    const headers = new Headers();
-    headers.set('Content-Type', event.request.headers.get('content-type') ?? 'application/json');
-    headers.set('x-omerlo-media-id', env.PRIVATE_OMERLO_MEDIA_ID ?? '');
-    headers.set('Authorization', `Bearer ${accessToken}`);
-    return await fetch(event.url.toString(), {
-        body, headers, method,
-        duplex: 'half'
-    })
+    const headers = new Headers({
+        'x-omerlo-media-id': env.PRIVATE_OMERLO_MEDIA_ID,
+        Authorization: `Bearer ${accessToken}`
+    });
+    const contentType = event.request.headers.get('content-type');
+    if (contentType)
+        headers.set('Content-Type', contentType);
+    return await fetch(event.url.toString(), { body, headers, method, duplex: 'half' })
         .then(async (resp) => {
         const headers = new Headers();
         if (resp.status === 401 && event.locals.accessToken) {
@@ -32,12 +31,12 @@ const handleApiProxy = async ({ event, ...tail }) => {
         const responseOpts = {
             headers: headers,
             status: resp.status,
-            statusText: resp.statusText,
+            statusText: resp.statusText
         };
         return new Response(resp.body, responseOpts);
     })
         .catch((err) => {
-        console.log("Could not proxy API request: ", err);
+        console.log('Could not proxy API request: ', err);
         error(500, 'Something went wrong');
     });
 };
@@ -45,13 +44,33 @@ export const proxyHook = async ({ event, resolve }) => {
     if (event.url.pathname.startsWith('/api/media/v1')) {
         return await handleApiProxy({ event, resolve });
     }
+    // TODO remove once every API will be done in Reader
+    if (event.url.pathname.startsWith('/api/publisher/')) {
+        const pathAfterPublisher = event.url.pathname.slice('/api/publisher/'.length);
+        const resourceConfigs = {
+            'media/': { idKey: env['PRIVATE_OMERLO_MEDIA_ID'], resourcePath: 'medias' },
+            'organization/': {
+                idKey: env['PRIVATE_OMERLO_ORGANIZATION_ID'],
+                resourcePath: 'organizations'
+            },
+            'issue/': { idKey: env['PRIVATE_OMERLO_ISSUE_ID'], resourcePath: 'issues' }
+        };
+        for (const [prefix, config] of Object.entries(resourceConfigs)) {
+            if (pathAfterPublisher.startsWith(prefix)) {
+                event.url.pathname = event.url.pathname.replace(`/api/publisher/${prefix}`, `/api/public/publisher/v2/${config.resourcePath}/${config.idKey}/`);
+                return handleApiProxy({ event, resolve });
+            }
+        }
+        event.url.pathname = event.url.pathname.replace('/api/publisher/', `/api/public/publisher/v2/`);
+        return handleApiProxy({ event, resolve });
+    }
     return resolve(event);
 };
 export const handleUserToken = async ({ event, resolve }) => {
     const accessToken = getAccessTokenFromCookie(event.cookies);
     const refreshToken = getRefreshTokenFromCookie(event.cookies);
     const opts = {
-        filterSerializedResponseHeaders: (name) => name == 'x-logout',
+        filterSerializedResponseHeaders: (name) => name == 'x-logout'
     };
     if (accessToken) {
         event.locals.accessToken = accessToken;

package/dist/omerlo/reader/server/index.d.ts

@@ -2,3 +2,4 @@ export declare const handleReaderApi: import("@sveltejs/kit").Handle;
 export declare const handleUserToken: import("@sveltejs/kit").Handle;
 export * from './token';
 export * from './utils';
+export * from './email';

package/dist/omerlo/reader/server/index.js

@@ -3,3 +3,4 @@ export const handleReaderApi = Hooks.proxyHook;
 export const handleUserToken = Hooks.handleUserToken;
 export * from './token';
 export * from './utils';
+export * from './email';

package/dist/omerlo/reader/server/token.d.ts

@@ -4,16 +4,16 @@ export interface exchangeAuthorizationCodeParams {
     oauthProviderId: string;
 }
 /**
-  * Exchange an authorization code for an omerlo's token.
-  */
+ * Exchange an authorization code for an omerlo's token.
+ */
 export declare function exchangeAuthorizationCode(params: exchangeAuthorizationCodeParams): Promise<OmerloToken>;
 /**
-  * Refresh the user's token.
-  */
+ * Refresh the user's token.
+ */
 export declare function refresh(refreshToken: string): Promise<OmerloToken>;
 /**
-  * Authenticate anonymously a user to get an anonymous token.
-  */
+ * Authenticate anonymously a user to get an anonymous token.
+ */
 export declare function getAnonymousToken(scope: string): Promise<OmerloToken>;
 export interface OmerloToken {
     accessToken: string;

package/dist/omerlo/reader/server/token.js

@@ -1,8 +1,8 @@
 import { env } from '$env/dynamic/private';
 import { ApiError } from '../utils/api';
 /**
-  * Exchange an authorization code for an omerlo's token.
-  */
+ * Exchange an authorization code for an omerlo's token.
+ */
 export async function exchangeAuthorizationCode(params) {
     const url = getTokenEndpoint();
     url.pathname = '/api/media/v1/oauth/token';
@@ -19,8 +19,8 @@ export async function exchangeAuthorizationCode(params) {
     throw new ApiError(resp.status, payload.error, resp.statusText);
 }
 /**
-  * Refresh the user's token.
-  */
+ * Refresh the user's token.
+ */
 export async function refresh(refreshToken) {
     const url = getTokenEndpoint();
     url.pathname = '/api/media/v1/oauth/token';
@@ -34,8 +34,8 @@ export async function refresh(refreshToken) {
     throw new ApiError(resp.status, payload.error, resp.statusText);
 }
 /**
-  * Authenticate anonymously a user to get an anonymous token.
-  */
+ * Authenticate anonymously a user to get an anonymous token.
+ */
 export async function getAnonymousToken(scope) {
     const url = getTokenEndpoint();
     url.pathname = '/api/media/v1/oauth/token';
@@ -58,6 +58,6 @@ function parseTokenResponse(data) {
         accessToken: data.access_token,
         refreshToken: data.refresh_token,
         expiresIn: data.expires_in,
-        tokenType: data.token_type,
+        tokenType: data.token_type
     };
 }

package/dist/omerlo/reader/server/utils.d.ts

@@ -1,6 +1,6 @@
-import type { UserSession } from "../stores/user_session";
+import type { UserSession } from '../stores/user_session';
 import type { Cookies } from '@sveltejs/kit';
-import { type OmerloToken } from "./token";
+import { type OmerloToken } from './token';
 export declare function loadUserSession(f: typeof fetch, cookies: Cookies): Promise<UserSession>;
 export declare function isAuthenticated(cookies: Cookies): boolean;
 export declare function setAuthorizationCookies(cookies: Cookies, token: OmerloToken): void;
@@ -9,6 +9,6 @@ export declare function clearAuthorizationUsingHeader(headers: Headers): void;
 export declare function getAccessTokenFromCookie(cookies: Cookies): string | null;
 export declare function getRefreshTokenFromCookie(cookies: Cookies): string | null;
 /**
-  * Get the token used by the application.
-  */
+ * Get the token used by the application.
+ */
 export declare function getApplicationToken(): Promise<string>;

package/dist/omerlo/reader/server/utils.js

@@ -1,11 +1,13 @@
-import { useReader } from "../..";
-import { getAnonymousToken, refresh } from "./token";
+import { useReader } from '../..';
+import { getAnonymousToken, refresh } from './token';
 export async function loadUserSession(f, cookies) {
     const userSession = { verified: false, authenticated: false, user: null };
     if (isAuthenticated(cookies)) {
         userSession.authenticated = true;
         try {
-            const userInfo = await useReader(f).userInfo().then((resp) => resp.data);
+            const userInfo = await useReader(f)
+                .userInfo()
+                .then((resp) => resp.data);
             userSession.verified = true;
             userSession.user = userInfo;
         }
@@ -22,7 +24,11 @@ const accessTokenCookieName = 'access_token';
 const refreshTokenCookieName = 'refresh_token';
 export function setAuthorizationCookies(cookies, token) {
     cookies.set('logged_in', 'true', { path: '/', httpOnly: false });
-    cookies.set(accessTokenCookieName, token.accessToken, { httpOnly: true, path: '/', maxAge: token.expiresIn - 60 });
+    cookies.set(accessTokenCookieName, token.accessToken, {
+        httpOnly: true,
+        path: '/',
+        maxAge: token.expiresIn - 60
+    });
     cookies.set(refreshTokenCookieName, token.refreshToken, { httpOnly: true, path: '/' });
 }
 export function clearAuthorizationCookies(cookies) {
@@ -46,11 +52,11 @@ const applicationToken = {
     accessToken: '',
     refreshToken: '',
     expiredAt: 0,
-    init: false,
+    init: false
 };
 /**
-  * Get the token used by the application.
-  */
+ * Get the token used by the application.
+ */
 export async function getApplicationToken() {
     if (!applicationToken.init) {
         await newApplicationToken();

package/dist/omerlo/reader/stores/user_session.d.ts

@@ -1,5 +1,5 @@
-import type { UserInfo } from "../endpoints/accounts";
-import { type Readable } from "svelte/store";
+import type { UserInfo } from '../endpoints/accounts';
+import { type Readable } from 'svelte/store';
 export interface UserSession {
     user: UserInfo | null;
     verified: boolean;

package/dist/omerlo/reader/stores/user_session.js

@@ -1,12 +1,12 @@
-import { getContext, setContext } from "svelte";
-import { writable } from "svelte/store";
-import { browser } from "$app/environment";
-import { useReader } from "../..";
-import { invalidate } from "$app/navigation";
+import { getContext, setContext } from 'svelte';
+import { writable } from 'svelte/store';
+import { browser } from '$app/environment';
+import { useReader } from '../..';
+import { invalidate } from '$app/navigation';
 const anonymousUserSession = {
     user: null,
     verified: false,
-    authenticated: false,
+    authenticated: false
 };
 export function initUserSession(session) {
     const { subscribe, update, set } = writable(session);
@@ -28,16 +28,18 @@ export function initUserSession(session) {
         subscribe,
         handleLogout: () => {
             if (!browser) {
-                throw new Error("MUST NOT call refresh on user session from server side.");
+                throw new Error('MUST NOT call refresh on user session from server side.');
             }
             invalidate('omerlo:user_session');
             update(updateUserInfo(null, false));
         },
         refresh: async () => {
             if (!browser) {
-                throw new Error("MUST NOT call refresh on user session from server side.");
+                throw new Error('MUST NOT call refresh on user session from server side.');
             }
-            const userInfo = await useReader(fetch).userInfo().then((resp) => resp.data);
+            const userInfo = await useReader(fetch)
+                .userInfo()
+                .then((resp) => resp.data);
             update(updateUserInfo(userInfo, true));
         }
     };

package/dist/omerlo/reader/utils/api.d.ts

@@ -1,5 +1,5 @@
 import { type Assoc } from './assocs';
-export type ApiAssocs = Record<string, Record<string, Assoc>>;
+export type ApiAssocs = Record<string, Assoc>;
 export declare function parseApiResponse<T>(response: Response, parser: (data: ApiData, assocs: ApiAssocs) => T): Promise<ApiResponse<T>>;
 export declare function parseMany<T>(parser: (data: ApiData, assocs: ApiAssocs) => T): (response: ApiData[], assocs: ApiAssocs) => T[];
 export interface ApiResponse<T> {

package/dist/omerlo/reader/utils/api.js

@@ -1,11 +1,12 @@
-import { parseAssocs } from './assocs';
+import { initAssocs, parseAssocs } from './assocs';
 export async function parseApiResponse(response, parser) {
     const payload = await response.json();
     let data = null, meta = null;
     if (response.ok) {
-        parseAssocs(payload.assocs);
+        const assocs = initAssocs(payload.assocs);
+        parseAssocs(assocs);
         meta = payload.meta;
-        data = parser(payload.data, payload.assocs);
+        data = parser(payload.data, assocs);
     }
     const errors = payload.errors || [];
     return { ok: response.ok, status: response.status, parser, meta, data, errors };

package/dist/omerlo/reader/utils/assocs.d.ts

@@ -1,5 +1,5 @@
-import type { ApiAssocs } from './api';
-export declare function registerAssocParser(assocName: string, parser: (arg: unknown) => unknown): void;
+import type { ApiAssocs, ApiData } from './api';
+export declare function registerAssocParser(assocName: string, parser: (apiData: unknown, assocs: ApiAssocs) => unknown): void;
 /**
  * Return the assoc corresponding the given `id`
  */
@@ -8,8 +8,9 @@ export declare function getAssoc<T>(assocs: ApiAssocs, name: string, id: string)
  * Return assocs corresponding given `ids`
  */
 export declare function getAssocs<T>(assocs: ApiAssocs, name: string, ids: string[]): T[];
+export declare function initAssocs(apiAssocs: ApiAssocs): Record<string, Record<string, Assoc>>;
 /**
  * Parse all assocs using an ordering system to prevent any clone.
  */
-export declare function parseAssocs(apiAssocs: ApiAssocs): void;
-export type Assoc = unknown;
+export declare function parseAssocs(apiAssocs: Record<string, Record<string, Assoc>>): void;
+export type Assoc = ApiData;

package/dist/omerlo/reader/utils/assocs.js

@@ -18,6 +18,25 @@ export function getAssoc(assocs, name, id) {
 export function getAssocs(assocs, name, ids) {
     return ids.map((id) => getAssoc(assocs, name, id));
 }
+export function initAssocs(apiAssocs) {
+    const result = {};
+    for (const assocName in apiAssocs) {
+        const assocs = apiAssocs[assocName];
+        result[assocName] = {};
+        // NOTE this is a workarround because we use publisher's api
+        // Once we remove publisher's api from reader, we should remove this condition.
+        if (!Array.isArray(assocs)) {
+            result[assocName] = assocs;
+            continue;
+        }
+        for (const assoc of assocs) {
+            // FIXME we should implement a assoc_id handler because event's return
+            // the occurrence id but the assoc's id is the event_id.
+            result[assocName][assoc.id] = assoc;
+        }
+    }
+    return result;
+}
 /**
  * Parse all assocs using an ordering system to prevent any clone.
  */
@@ -26,6 +45,10 @@ export function parseAssocs(apiAssocs) {
         const assocs = apiAssocs[assocName];
         for (const assocId in assocs) {
             const assoc = assocs[assocId];
+            if (!assocsParsers[assocName]) {
+                console.error(`No assoc parser found for ${assocName}`);
+                continue;
+            }
             assocs[assocId] = assocsParsers[assocName](assoc, apiAssocs);
         }
     }

package/dist/omerlo/reader/utils/parseHelpers.d.ts

@@ -0,0 +1,7 @@
+export declare function buildMeta(locale: string | null): {
+    locales: {
+        available: string[];
+        current: string;
+    };
+};
+export declare function parseDate(input?: string | null): Date | null;

package/dist/omerlo/reader/utils/parseHelpers.js

@@ -0,0 +1,22 @@
+export function buildMeta(locale) {
+    if (!locale) {
+        return {
+            locales: {
+                available: ['en'],
+                current: 'en'
+            }
+        };
+    }
+    return {
+        locales: {
+            available: [locale],
+            current: locale
+        }
+    };
+}
+export function parseDate(input) {
+    if (!input)
+        return null;
+    const date = new Date(input);
+    return isNaN(date.getTime()) ? null : date;
+}

package/dist/omerlo/reader/utils/request.d.ts

@@ -1,17 +1,19 @@
 import type { ApiAssocs, ApiData, ApiResponse } from './api';
-type FetchOptions<T> = {
-    parser?: (data: ApiData, assocs: ApiAssocs) => T;
-    queryParams?: ApiData;
-    method?: 'get' | 'post' | 'put' | 'delete';
-    body?: ApiData;
-    headers?: Headers;
+type FetchOptions<T> = Required<DirtyFetchOptions> & {
+    parser: (data: ApiData, assocs: ApiAssocs) => T;
 };
-export declare function request<T>(f: typeof fetch, path: string, opts: FetchOptions<T>): Promise<ApiResponse<T>>;
+export declare function request<T>(f: typeof fetch, path: string, opts: Partial<FetchOptions<T>>): Promise<ApiResponse<T>>;
 type DirtyFetchOptions = {
     queryParams?: ApiData;
-    method?: 'get' | 'post' | 'put' | 'delete';
+    method?: 'get' | 'post' | 'patch' | 'put' | 'delete';
     body?: ApiData;
     headers?: Headers;
 };
 export declare function dirtyRequest(f: typeof fetch, path: string, opts: DirtyFetchOptions): Promise<Response>;
+/**
+ * NOTE: This is for OLD api and will be removed once every API will
+ * be developped in Reader.
+ */
+export declare function requestPublisher<T>(f: typeof fetch, path: string, opts: Partial<FetchOptions<T>>): Promise<ApiResponse<T>>;
+export declare function dirtyRequestPublisher(f: typeof fetch, path: string, opts: DirtyFetchOptions): Promise<Response>;
 export {};

package/dist/omerlo/reader/utils/request.js

@@ -1,17 +1,24 @@
 import { parseApiResponse } from './api';
 import { BROWSER } from 'esm-env';
-export async function request(f, path, opts) {
-    const parser = opts.parser || ((data) => data);
-    const body = JSON.stringify(opts.body);
-    const headers = opts.headers;
-    const method = opts.method ?? 'get';
-    const queryParams = opts.queryParams;
-    // Enforce JSON content type for posts
-    if (!opts.headers) {
-        opts.headers = new Headers();
+function parseRequestOpts(params) {
+    const headers = params.headers ?? new Headers();
+    const method = params.method ?? 'get';
+    if (!headers.has('Accept')) {
+        headers.set('Accept', 'application/json');
+    }
+    if (!headers.has('Content-Type') && ['post', 'put', 'patch'].includes(method)) {
+        headers.set('Content-Type', 'application/json');
     }
-    if (['post', 'put'].includes(method) && !opts.headers.get('Content-Type'))
-        opts.headers.set('Content-Type', 'application/json');
+    return {
+        queryParams: params.queryParams,
+        body: JSON.stringify(params.body),
+        method: params.method ?? 'get',
+        headers: headers,
+        parser: params.parser || ((data) => data)
+    };
+}
+export async function request(f, path, opts) {
+    const { body, headers, method, queryParams, parser } = parseRequestOpts(opts);
     return dirtyRequest(f, path, { body, headers, method, queryParams }).then(async (resp) => {
         return parseApiResponse(resp, parser);
     });
@@ -34,3 +41,24 @@ export async function dirtyRequest(f, path, opts) {
     }
     return resp;
 }
+/**
+ * NOTE: This is for OLD api and will be removed once every API will
+ * be developped in Reader.
+ */
+export async function requestPublisher(f, path, opts) {
+    const { body, headers, method, queryParams, parser } = parseRequestOpts(opts);
+    return dirtyRequestPublisher(f, path, { body, headers, method, queryParams }).then(async (resp) => {
+        return parseApiResponse(resp, parser);
+    });
+}
+export async function dirtyRequestPublisher(f, path, opts) {
+    const queryParams = new URLSearchParams();
+    path = `/api/publisher/${path}`;
+    if (opts?.queryParams) {
+        Object.entries(opts.queryParams).forEach(([key, value]) => {
+            queryParams.append(key, String(value));
+        });
+        path = `${path}?${queryParams}`;
+    }
+    return f(path.toString(), opts);
+}

package/dist/omerlo/reader/utils/response.d.ts

@@ -1,4 +1,4 @@
-import type { ApiData } from "./api";
+import type { ApiData } from './api';
 export interface LocalesMetadata {
     current: string;
     available: string[];

package/dist/omerlo/reader/utils/response.js

@@ -1,6 +1,6 @@
 export function parseLocalesMetadata(meta) {
     return {
         current: meta.current,
-        available: meta.available,
+        available: meta.available
     };
 }

package/eslint.config.js

@@ -16,7 +16,7 @@ export default ts.config(
     languageOptions: {
       globals: {
         ...globals.browser,
-        ...globals.node,
+        ...globals.node
       },
       parserOptions: {
         parser: ts.parser
@@ -28,7 +28,16 @@ export default ts.config(
   },
   {
     rules: {
-      '@typescript-eslint/no-unused-vars': ['warn', { argsIgnorePattern: '^_' }]
+      '@typescript-eslint/no-unused-vars': [
+        'warn',
+        {
+          argsIgnorePattern: '^_',
+          caughtErrorsIgnorePattern: '^_'
+        }
+      ]
     }
+  },
+  {
+    ignores: ['.svelte-kit/**', 'build/**', 'dist/**', 'example/.svelte-kit']
   }
 );