@tanglemedia/svelte-starter-directus-api 0.0.15 → 0.1.0

package/dist/adapter/api-adapter.d.ts

@@ -0,0 +1,22 @@
+import { type DirectusClient, type RestClient } from '@directus/sdk';
+import { ApiAdapterAbstract, type AnyObject, type ApiAdapterRequestConfig, type ApiId, type ApiResponse, type BaseApiMethods } from '@tanglemedia/svelte-starter-core';
+import type { DirectusConfig, SchemaShape } from '../types/adapter.types';
+export type AdapterClient<Schema extends SchemaShape = SchemaShape> = DirectusClient<Schema> & RestClient<Schema>;
+export declare class DirectusApiAdapter<Schema extends SchemaShape = SchemaShape, Path extends string = keyof SchemaShape> extends ApiAdapterAbstract<DirectusConfig, ApiAdapterRequestConfig, Path, AdapterClient> {
+    protected config: DirectusConfig;
+    private readonly directus;
+    constructor(config: DirectusConfig, directus: AdapterClient<Schema>);
+    getAdapterClient(): AdapterClient<Schema> | null;
+    normalizeMeta(payload: AnyObject): AnyObject;
+    transformResponse<T, M extends object = AnyObject>(res: T, status?: number): Promise<ApiResponse<T, Response, M>>;
+    getConfig(configuration?: unknown): DirectusConfig;
+    request<T>(method: BaseApiMethods, url: string, query?: Record<string, unknown>): Promise<T>;
+    find<T>(collection: Path, query?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    findOne<T>(collection: Path, key?: ApiId, query?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    aggregate<T>(collection: Path, query?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    patch<T>(collection: Path, key: ApiId, query?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    post<T>(collection: Path, data: AnyObject, query?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    delete<T>(collection: Path, key?: ApiId): Promise<ApiResponse<T>>;
+    put<T>(collection: Path, key?: ApiId, payload?: AnyObject, config?: ApiAdapterRequestConfig): Promise<ApiResponse<T>>;
+    upload<T>(path: string | undefined, data: FormData): Promise<ApiResponse<T>>;
+}

package/dist/adapter/api-adapter.js

@@ -0,0 +1,100 @@
+import { aggregate, createItem, deleteItem, readItem, readItems, updateItem, uploadFiles } from '@directus/sdk';
+import { ApiAdapterAbstract } from '@tanglemedia/svelte-starter-core';
+export class DirectusApiAdapter extends ApiAdapterAbstract {
+    config;
+    directus;
+    constructor(config, directus) {
+        super(config);
+        this.config = config;
+        this.directus = directus;
+    }
+    getAdapterClient() {
+        return this.directus;
+    }
+    normalizeMeta(payload) {
+        // todo: Transform or attempt to get meta information
+        // consider pulling count based on existing filters in order to determine pagination
+        return payload;
+    }
+    async transformResponse(res, status = 200) {
+        // const payload = (await res.json()) as T;
+        return {
+            body: await this.envelopeResponse(res.data || res
+            // this.normalizeMeta(payload as AnyObject) as M
+            ),
+            status: status,
+            statusText: 'OK',
+            headers: {},
+            adapterResponse: null
+        };
+    }
+    getConfig(configuration) {
+        const client = this.directus;
+        // Add the 'configuration' property to the returned object
+        const config = {
+            ...this.config,
+            configuration: configuration ?? {} // Use the provided configuration or an empty object if not provided
+        };
+        return Object.assign(client, config);
+    }
+    async request(method, url, query) {
+        try {
+            const response = await this.directus.request(() => {
+                const params = JSON.stringify(query);
+                return {
+                    path: `${url}?${params}`,
+                    method: method
+                };
+            });
+            return response;
+        }
+        catch (error) {
+            console.error(`Error request:`, error);
+            throw error;
+        }
+    }
+    async find(collection, query) {
+        const response = await this.directus.request(readItems(collection, query));
+        return this.transformResponse(response);
+    }
+    async findOne(collection, key, query) {
+        const response = await this.directus.request(readItem(collection, key, query));
+        return this.transformResponse(response);
+    }
+    async aggregate(collection, query) {
+        const response = await this.directus.request(aggregate(collection, {
+            aggregate: {
+                count: 'id'
+            },
+            query
+        }));
+        return this.transformResponse(response);
+    }
+    async patch(collection, key, query) {
+        const response = await this.directus.request(updateItem(collection, key, query));
+        return this.transformResponse(response);
+    }
+    async post(collection, data, query) {
+        const response = await this.directus.request(createItem(collection, data, query));
+        return this.transformResponse(response, 201);
+    }
+    async delete(collection, key) {
+        const response = await this.directus.request(deleteItem(collection, key));
+        return this.transformResponse(response, 202);
+    }
+    async put(collection, key, payload, config) {
+        if (key) {
+            const response = await this.directus.request(updateItem(collection, key, payload));
+            return this.transformResponse(response, 201);
+        }
+        else {
+            console.error(`Error updating all ${collection}: no key specified`);
+            throw new Error('No key specified');
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async upload(path = '', data) {
+        const response = await this.directus.request(uploadFiles(data));
+        return this.transformResponse(response, 201);
+    }
+}

package/dist/{auth.js → auth.deprecated.js}

@@ -1,50 +1,11 @@
-import { authentication, createDirectus, readMe, refresh, rest, updateMe, memoryStorage } from '@directus/sdk';
-import { BROWSER } from 'esm-env';
-import cookie from 'js-cookie';
-const localDirectusStorage = (storageKey = 'access_token_directus') => {
-    if (!BROWSER || !window.localStorage) {
-        console.warn('Defaulting to memory storage');
-        return memoryStorage();
-    }
-    const storage = window.localStorage;
-    return {
-        get: async () => {
-            const data = storage.getItem(storageKey);
-            return data ? JSON.parse(data) : null;
-        },
-        set: async (value) => {
-            if (value === null) {
-                storage.removeItem(storageKey);
-            }
-            else {
-                storage.setItem(storageKey, JSON.stringify(value));
-            }
-        }
-    };
-};
-// const cookieDirectusStorage = (cookieKey: string = 'access_token_directus') => {
-//   return {
-//     get: async (): Promise<AuthenticationData | null> => {
-//       const data = JSON.parse(cookie.get(cookieKey)) || '{}';
-//       return data ? (data as AuthenticationData) : null;
-//     },
-//     set: async (value: AuthenticationData | null): Promise<void> => {
-//       cookie.set(cookieKey, JSON.stringify(value))
-//     }
-//   };
-// }
+import { authentication, createDirectus, readMe, refresh, rest, updateMe } from '@directus/sdk';
+import { AuthLocalStorage } from './storage/local-storage';
 const authenticationConfig = {
-    storage: localDirectusStorage(),
+    storage: new AuthLocalStorage(),
     autoRefresh: true,
     msRefreshBeforeExpires: 30000,
     credentials: 'include'
 };
-// const authenticationCookieConfig: AuthenticationConfig = {
-//   storage: cookieDirectusStorage(),
-//   autoRefresh: true,
-//   msRefreshBeforeExpires: 30000,
-//   credentials: 'include'
-// };
 class ApiAuthDirectus {
     baseURL;
     storageMode;

package/dist/{client.js → client.deprecated.js}

@@ -1,40 +1,7 @@
-import { aggregate, authentication, createDirectus, createItem, deleteItem, readItem, readItems, rest, updateItem, uploadFiles, memoryStorage } from '@directus/sdk';
-import { browser } from '$app/environment';
-import cookie from 'js-cookie';
-const localDirectusStorage = (storageKey = 'access_token_directus') => {
-    if (!browser || !window.localStorage) {
-        console.warn('Defaulting to memory storage');
-        return memoryStorage();
-    }
-    const storage = window.localStorage;
-    return {
-        get: async () => {
-            const data = storage.getItem(storageKey);
-            return data ? JSON.parse(data) : null;
-        },
-        set: async (value) => {
-            if (value === null) {
-                storage.removeItem(storageKey);
-            }
-            else {
-                storage.setItem(storageKey, JSON.stringify(value));
-            }
-        }
-    };
-};
-// const cookieDirectusStorage = (cookieKey: string = 'access_token_directus') => {
-//   return {
-//     get: async (): Promise<AuthenticationData | null> => {
-//       const data = JSON.parse(cookie.get(cookieKey)) || '{}';
-//       return data ? (data as AuthenticationData) : null;
-//     },
-//     set: async (value: AuthenticationData | null): Promise<void> => {
-//       cookie.set(cookieKey, JSON.stringify(value))
-//     }
-//   };
-// }
+import { aggregate, authentication, createDirectus, createItem, deleteItem, readItem, readItems, rest, updateItem, uploadFiles } from '@directus/sdk';
+import { AuthLocalStorage } from './storage/local-storage';
 const authenticationConfig = {
-    storage: localDirectusStorage(),
+    storage: new AuthLocalStorage(),
     autoRefresh: true,
     msRefreshBeforeExpires: 30000,
     credentials: 'include'

package/dist/index.d.ts

@@ -1,4 +1,9 @@
-export * from './static';
-export * from './client';
-export * from './auth';
-export * from './load-directus-api-povider';
+export * from './static.deprecated';
+export * from './client.deprecated';
+export * from './auth.deprecated';
+export * from './load-directus-api-povider.deprecated';
+export * from './provider/api-adapter.provider';
+export * from './provider/directus.factory';
+export * from './services/auth';
+export * from './services/register';
+export type * from './types';

package/dist/index.js

@@ -1,4 +1,8 @@
-export * from './static';
-export * from './client';
-export * from './auth';
-export * from './load-directus-api-povider';
+export * from './static.deprecated';
+export * from './client.deprecated';
+export * from './auth.deprecated';
+export * from './load-directus-api-povider.deprecated';
+export * from './provider/api-adapter.provider';
+export * from './provider/directus.factory';
+export * from './services/auth';
+export * from './services/register';

package/dist/{load-directus-api-povider.d.ts → load-directus-api-povider.deprecated.d.ts}

@@ -2,9 +2,10 @@ import { type ApiAdapterProviderInterface, type ApiAdapterInterface, type ApiAda
 declare class LoadDirectusApiProvider implements ApiAdapterProviderInterface {
     private readonly configLoader;
     private storageMode;
+    private key?;
     constructor(configLoader: () => Promise<Config<{
         api?: ApiConfigSchema;
-    }>>, storageMode?: 'json' | 'cookie');
-    loadAdapter(key?: string | undefined): Promise<ApiAdapterInterface<BaseApiAdapterConfig, ApiAdapterRequestConfig, string>>;
+    }>>, storageMode?: 'json' | 'cookie', key?: string | undefined);
+    loadAdapter(): Promise<ApiAdapterInterface<BaseApiAdapterConfig, ApiAdapterRequestConfig, string>>;
 }
 export { LoadDirectusApiProvider };

package/dist/{load-directus-api-povider.js → load-directus-api-povider.deprecated.js}

@@ -1,32 +1,39 @@
-import { ApiClientDirectus } from './client';
-import { ApiStaticDirectus } from './static';
+import { ApiClientDirectus } from './client.deprecated';
+import { ApiStaticDirectus } from './static.deprecated';
+import { ApiAuthDirectus } from './auth.deprecated';
 import {} from '@tanglemedia/svelte-starter-core';
 class LoadDirectusApiProvider {
     configLoader;
     storageMode;
-    constructor(configLoader, storageMode = 'json') {
+    key;
+    constructor(configLoader, storageMode = 'json', key) {
         this.configLoader = configLoader;
         this.storageMode = storageMode;
+        this.key = key;
     }
-    async loadAdapter(key) {
+    async loadAdapter() {
         const conf = await this.configLoader();
         const config = (p) => conf.config(p);
-        const apiAdapterKey = key || config('api.default');
-        const directusType = config(`api.adapters.${apiAdapterKey}.type`) || 'client';
+        const apiAdapterKey = this.key === 'auth' ? 'auth' : this.key || config('api.default');
+        const directusType = apiAdapterKey === 'auth'
+            ? this.key
+            : config(`api.adapters.${apiAdapterKey}.type`) || 'client';
         console.log(`api.apaters.${apiAdapterKey}.type`);
         if (!apiAdapterKey) {
             throw new Error(`No adapter key specified`);
         }
-        console.log(apiAdapterKey);
-        console.log(directusType);
         if (directusType) {
             if (directusType === 'client') {
                 const protocol = config(`api.adapters.${apiAdapterKey}.protocol`) || '';
                 const host = config(`api.adapters.${apiAdapterKey}.host`) || '';
                 return new ApiClientDirectus(`${protocol}://${host}`.trim(), this.storageMode);
             }
+            else if (directusType === 'auth') {
+                const protocol = config(`api.adapters.${apiAdapterKey}.protocol`) || '';
+                const host = config(`api.adapters.${apiAdapterKey}.host`) || '';
+                return new ApiAuthDirectus(`${protocol}://${host}`.trim(), this.storageMode);
+            }
             else {
-                console.log('static');
                 const protocol = config(`api.adapters.${apiAdapterKey}.protocol`) || '';
                 const host = config(`api.adapters.${apiAdapterKey}.host`) || '';
                 const accessToken = config(`api.adapters.${apiAdapterKey}.access_token`) || '';
@@ -34,12 +41,10 @@ class LoadDirectusApiProvider {
             }
         }
         else {
-            console.log('client');
             const protocol = config(`api.adapters.${apiAdapterKey}.protocol`) || '';
             const host = config(`api.adapters.${apiAdapterKey}.host`) || '';
             return new ApiClientDirectus(`${protocol}://${host}`.trim(), this.storageMode);
         }
-        console.log('This should be unreachable');
     }
 }
 export { LoadDirectusApiProvider };

package/dist/provider/api-adapter.provider.d.ts

@@ -0,0 +1,7 @@
+import type { AdapterProviderRegister, ApiAdapterInterface, ApiAdapterProviderInterface } from '@tanglemedia/svelte-starter-core';
+import type { DirectusConfig } from '../types/adapter.types';
+export declare class DirectusApiProvider implements ApiAdapterProviderInterface<DirectusConfig> {
+    loadAdapter(key?: string, config?: DirectusConfig): Promise<ApiAdapterInterface<DirectusConfig>>;
+    createDirectusClient<T extends object>(config: DirectusConfig): import("@directus/sdk/dist/client-pzVdw9Ub").D<T> & import("@directus/sdk/dist/login-M53C1LeV").e<T>;
+}
+export declare const registerDirectusProvider: () => AdapterProviderRegister;

package/dist/provider/api-adapter.provider.js

@@ -0,0 +1,21 @@
+import { DirectusApiAdapter } from '../adapter/api-adapter';
+import { createDirectusClientFactory } from './directus.factory';
+export class DirectusApiProvider {
+    async loadAdapter(key, config) {
+        if (!config) {
+            throw new Error('Missing adapter configuration');
+        }
+        const client = this.createDirectusClient(config);
+        return new DirectusApiAdapter(config, client);
+    }
+    createDirectusClient(config) {
+        // todo: Determine if we can overwrite the fetch globals during runtime
+        return createDirectusClientFactory(config);
+    }
+}
+export const registerDirectusProvider = () => {
+    return {
+        name: 'directus',
+        provider: new DirectusApiProvider()
+    };
+};

package/dist/provider/directus.factory.d.ts

@@ -0,0 +1,6 @@
+import { type ClientOptions } from '@directus/sdk';
+import type { DirectusConfig } from '../types/adapter.types';
+/**
+ * Creates a directus client based on the application configuration
+ */
+export declare const createDirectusClientFactory: <T extends object>({ baseUrl, configuration: { protocol, host, auth, staticToken: token, graphql: gql, rest: rs } }: DirectusConfig, options?: ClientOptions) => import("@directus/sdk/dist/client-pzVdw9Ub").D<T> & import("@directus/sdk/dist/login-M53C1LeV").e<T>;

package/dist/provider/directus.factory.js

@@ -0,0 +1,46 @@
+import { authentication, createDirectus, graphql, rest, staticToken } from '@directus/sdk';
+import { AuthLocalStorage } from '../storage/local-storage';
+const authConfigDefaults = {
+    autoRefresh: false,
+    msRefreshBeforeExpires: 0,
+    credentials: 'include'
+};
+/**
+ * Creates a directus client based on the application configuration
+ */
+export const createDirectusClientFactory = ({ baseUrl, configuration: { protocol = 'https', host, auth, staticToken: token, graphql: gql, rest: rs } }, options) => {
+    let url = baseUrl;
+    if (host) {
+        url = `${protocol}://${host}`;
+    }
+    if (!url) {
+        throw new Error('Unable to resolve base url for directus client');
+    }
+    // if there is going to be authentication and no rest config has been specified.
+    // set the correct defaults
+    if (!rs && auth) {
+        rs = { credentials: 'include' };
+    }
+    let client = createDirectus(url, options).with(rest(rs));
+    if (auth) {
+        if (auth.config?.storage === 'localStorage') {
+            const authenticationConfig = {
+                storage: new AuthLocalStorage(),
+                autoRefresh: auth.config.autoRefresh || false,
+                msRefreshBeforeExpires: auth.config.msRefreshBeforeExpires || 0,
+                credentials: auth.config.credentials || 'include'
+            };
+            client = client.with(authentication(auth.mode, authenticationConfig));
+        }
+        else {
+            client = client.with(authentication(auth.mode));
+        }
+    }
+    if (token) {
+        client = client.with(staticToken(token));
+    }
+    if (gql) {
+        client = client.with(graphql(gql));
+    }
+    return client;
+};

package/dist/services/auth.d.ts

@@ -0,0 +1,13 @@
+import type { AuthenticationClient } from '@directus/sdk';
+import type { DirectusClient, RestClient } from '@directus/sdk';
+import { ServiceAdapterAbstract } from '@tanglemedia/svelte-starter-core';
+declare class DirectusAuthServices extends ServiceAdapterAbstract {
+    getDirectus(): Promise<DirectusClient<object> & RestClient<object> & AuthenticationClient<object>>;
+    refresh<T>(): Promise<T>;
+    getToken(): Promise<string | null>;
+    login(email: string, password: string): Promise<import("@directus/sdk/dist/login-M53C1LeV").a>;
+    logout(): Promise<void>;
+    getCurrentUser<T>(fields?: string[] | null): Promise<T>;
+    updateCurrentUser<T>(data: object): Promise<T>;
+}
+export { DirectusAuthServices };

package/dist/services/auth.js

@@ -0,0 +1,75 @@
+import { readMe, refresh, updateMe } from '@directus/sdk';
+import { ServiceAdapterAbstract } from '@tanglemedia/svelte-starter-core';
+class DirectusAuthServices extends ServiceAdapterAbstract {
+    getDirectus() {
+        return this.getAdapterClient();
+    }
+    // public getConfig<T extends object>(): DirectusClient<T> & RestClient<object> {
+    //   return this.directus as DirectusClient<T> & RestClient<object>;
+    // }
+    async refresh() {
+        try {
+            const response = await (await this.getDirectus()).request(refresh());
+            return response;
+        }
+        catch (error) {
+            console.error(`Error refreshing :`, error);
+            throw error;
+        }
+    }
+    async getToken() {
+        try {
+            const response = await (await this.getDirectus()).getToken();
+            return response;
+        }
+        catch (error) {
+            console.error(`Error refreshing :`, error);
+            throw error;
+        }
+    }
+    async login(email, password) {
+        try {
+            const response = await (await this.getDirectus()).login(email, password);
+            return response;
+        }
+        catch (error) {
+            console.error(`Error login :`, error);
+            throw error;
+        }
+    }
+    async logout() {
+        try {
+            const response = await (await this.getDirectus()).logout();
+            return response;
+        }
+        catch (error) {
+            console.error(`Error refreshing :`, error);
+            throw error;
+        }
+    }
+    async getCurrentUser(fields = null) {
+        try {
+            if (!this.getToken())
+                await this.refresh();
+            const response = await (await this.getDirectus()).request(readMe({ fields: fields ? fields : ['*', 'roles.*'] }));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error refreshing :`, error);
+            throw error;
+        }
+    }
+    async updateCurrentUser(data) {
+        try {
+            if (!this.getToken())
+                await this.refresh();
+            const response = await (await this.getDirectus()).request(updateMe(data));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error refreshing :`, error);
+            throw error;
+        }
+    }
+}
+export { DirectusAuthServices };

package/dist/services/register.d.ts

@@ -0,0 +1,16 @@
+import type { AuthenticationClient, DirectusClient, RestClient } from '@directus/sdk';
+import { ServiceAdapterAbstract } from '@tanglemedia/svelte-starter-core';
+declare class DirectusStaticServices extends ServiceAdapterAbstract {
+    getDirectus(): Promise<DirectusClient<object> & RestClient<object> & AuthenticationClient<object>>;
+    createUser(data: {
+        email: string;
+        password: string;
+        first_name: string;
+        last_name: string;
+        role: string;
+    } | object): Promise<{
+        message: string;
+        type: string;
+    }>;
+}
+export { DirectusStaticServices };

package/dist/services/register.js

@@ -0,0 +1,18 @@
+import { createUser } from '@directus/sdk';
+import { ServiceAdapterAbstract } from '@tanglemedia/svelte-starter-core';
+class DirectusStaticServices extends ServiceAdapterAbstract {
+    getDirectus() {
+        return this.getAdapterClient();
+    }
+    async createUser(data) {
+        try {
+            await (await this.getDirectus()).request(createUser(data));
+            return { message: 'You have successfully registered your account', type: 'success' };
+        }
+        catch (error) {
+            console.error(`Error creating a user:`, error);
+            throw error;
+        }
+    }
+}
+export { DirectusStaticServices };

package/dist/static.deprecated.d.ts

@@ -0,0 +1,22 @@
+import type { BaseApiAdapterConfig } from '@tanglemedia/svelte-starter-core';
+type BaseApiMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+declare class ApiStaticDirectus {
+    private baseURL;
+    private directusAccessToken;
+    private directus;
+    constructor(baseURL: string, directusAccessToken: string);
+    private init;
+    getConfig<T extends object>(configuration?: unknown): BaseApiAdapterConfig;
+    request<T>(method: BaseApiMethods, url: string, query?: Record<string, unknown>): Promise<T>;
+    createUser(data: {
+        email: string;
+        password: string;
+        first_name: string;
+        last_name: string;
+        role: string;
+    } | object): Promise<{
+        message: string;
+        type: string;
+    }>;
+}
+export { ApiStaticDirectus };

package/dist/static.deprecated.js

@@ -0,0 +1,58 @@
+import { createDirectus, createUser, rest, staticToken } from '@directus/sdk';
+class ApiStaticDirectus {
+    baseURL;
+    directusAccessToken;
+    directus;
+    constructor(baseURL, directusAccessToken) {
+        this.baseURL = baseURL;
+        this.directusAccessToken = directusAccessToken;
+        this.init();
+    }
+    init() {
+        try {
+            this.directus = createDirectus(this.baseURL)
+                .with(rest())
+                .with(staticToken(this.directusAccessToken));
+        }
+        catch (error) {
+            console.error(`Error initializing Directus admin:`, error);
+            throw error;
+        }
+    }
+    getConfig(configuration) {
+        // return this.directus as DirectusClient<T> & RestClient<object>;
+        const client = this.directus;
+        // Add the 'configuration' property to the returned object
+        const config = {
+            configuration: configuration ?? {} // Use the provided configuration or an empty object if not provided
+        };
+        return Object.assign(client, config);
+    }
+    async request(method, url, query) {
+        try {
+            const response = await this.directus.request(() => {
+                const params = JSON.stringify(query);
+                return {
+                    path: `${url}?${params}`,
+                    method: method
+                };
+            });
+            return response;
+        }
+        catch (error) {
+            console.error(`Error request:`, error);
+            throw error;
+        }
+    }
+    async createUser(data) {
+        try {
+            await this.directus.request(createUser(data));
+            return { message: 'You have successfully registered your account', type: 'success' };
+        }
+        catch (error) {
+            console.error(`Error creating a user:`, error);
+            throw error;
+        }
+    }
+}
+export { ApiStaticDirectus };

package/dist/storage/local-storage.d.ts

@@ -0,0 +1,9 @@
+import type { AuthenticationStorage, AuthenticationData } from '@directus/sdk';
+export declare class AuthLocalStorage implements AuthenticationStorage {
+    #private;
+    private readonly storageKey;
+    constructor(storageKey?: string);
+    get key(): string;
+    get(): Promise<AuthenticationData | null>;
+    set(value: AuthenticationData | null): Promise<void>;
+}

package/dist/storage/local-storage.js

@@ -0,0 +1,30 @@
+import { BROWSER } from 'esm-env';
+import { LocalStoragePolyFill } from '@tanglemedia/svelte-starter-core';
+const loadStorage = () => {
+    return BROWSER && window && window.localStorage
+        ? window.localStorage
+        : new LocalStoragePolyFill();
+};
+export class AuthLocalStorage {
+    storageKey;
+    #storage = loadStorage();
+    constructor(storageKey = 'access_token_directus') {
+        this.storageKey = storageKey;
+    }
+    get key() {
+        return this.storageKey;
+    }
+    // get: () => a | Promise<a | null> | null;
+    async get() {
+        const data = this.#storage.getItem(this.key);
+        return data ? JSON.parse(data) : null;
+    }
+    async set(value) {
+        if (value === null) {
+            this.#storage.removeItem(this.key);
+        }
+        else {
+            this.#storage.setItem(this.key, JSON.stringify(value));
+        }
+    }
+}