firstly 0.0.6 → 0.0.8

package/esm/auth/client/Auth.js

@@ -6,15 +6,26 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { BackendMethod } from 'remult';
 export class Auth {
+    // Do not show for firstly users ?
+    /** DO NOT USE */
     static signOutFn;
+    /** DO NOT USE */
     static signInDemoFn;
+    /** DO NOT USE */
     static inviteFn;
+    /** DO NOT USE */
     static signUpPasswordFn;
+    /** DO NOT USE */
     static signInPasswordFn;
+    /** DO NOT USE */
     static forgotPasswordFn;
+    /** DO NOT USE */
     static resetPasswordFn;
+    /** DO NOT USE */
     static signInOTPFn;
+    /** DO NOT USE */
     static verifyOtpFn;
+    /** DO NOT USE */
     static signInOAuthGetUrlFn;
     /**
      * Sign out the current user
@@ -30,22 +41,19 @@ export class Auth {
         return await Auth.signInDemoFn(name);
     }
     /**
-     * This is for login / password authentication SignUp
-     * _(The first param `name` can be "anything")_
+     * This is for login / password authentication Invite someone
      */
     static async invite(email) {
         return await Auth.inviteFn(email);
     }
     /**
      * This is for login / password authentication SignUp
-     * _(The first param `email` can be "anything")_
      */
     static async signUpPassword(email, password) {
         return await Auth.signUpPasswordFn(email, password);
     }
     /**
      * This is for login / password authentication SignIn
-     * _(The first param `email` can be "anything")_
      */
     static async signInPassword(email, password) {
         return await Auth.signInPasswordFn(email, password);
@@ -96,7 +104,7 @@ __decorate([
     BackendMethod({ allowed: true })
 ], Auth, "signInDemo", null);
 __decorate([
-    BackendMethod({ allowed: false })
+    BackendMethod({ allowed: true })
 ], Auth, "invite", null);
 __decorate([
     BackendMethod({ allowed: true })

package/esm/auth/{Entities.d.ts → client/Entities.d.ts}

@@ -1,5 +1,5 @@
-import { BaseEnum } from '../';
-import type { BaseEnumOptions } from '../';
+import { BaseEnum } from '../..';
+import type { BaseEnumOptions } from '../..';
 export declare const FF_Auth_Role: {
     readonly Admin: "FF_Auth_Role.Admin";
 };
@@ -7,7 +7,7 @@ export declare class FFAuthUser {
     id: string;
     createdAt: Date;
     updatedAt?: Date;
-    name: string;
+    identifier: string;
     roles: string[];
     accounts: FFAuthAccount[];
     sessions: FFAuthUserSession[];

package/esm/auth/{Entities.js → client/Entities.js}

@@ -5,8 +5,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 var FFAuthProvider_1;
-import { Entity, Fields, Relations, Validators, ValueListFieldType } from 'remult';
-import { BaseEnum, FF_Role } from '../';
+import { Fields, Relations, Validators, ValueListFieldType } from 'remult';
+import { BaseEnum, FF_Entity, FF_Role } from '../..';
 export const FF_Auth_Role = {
     Admin: 'FF_Auth_Role.Admin',
 };
@@ -14,7 +14,7 @@ let FFAuthUser = class FFAuthUser {
     id;
     createdAt;
     updatedAt;
-    name;
+    identifier;
     roles = [];
     accounts;
     sessions;
@@ -32,18 +32,28 @@ __decorate([
     Fields.string({
         validate: [
             Validators.unique(),
+            Validators.required(),
             (e) => {
-                if (e.name.length < 2)
+                if (e.identifier?.length < 2)
                     throw 'Must be at least 2 characters long';
             },
         ],
     })
-], FFAuthUser.prototype, "name", void 0);
+], FFAuthUser.prototype, "identifier", void 0);
 __decorate([
-    Fields.object({
+    Fields.json(() => [], {
+        inputType: 'selectEnum',
         valueConverter: {
-            toDb: (x) => (x ? x.join(',') : undefined),
-            fromDb: (x) => (x ? x.split(',') : undefined),
+            toDb: (x) => (x ? x.join(',') : []),
+            //FIXME: refacto this + remove "permissions" & add a disable user!
+            fromDb: (x) => {
+                return x
+                    ? x
+                        .split(',')
+                        .map((c) => c.replace('{', '').replace('}', ''))
+                        .filter((c) => c !== '')
+                    : [];
+            },
         },
     })
 ], FFAuthUser.prototype, "roles", void 0);
@@ -54,9 +64,9 @@ __decorate([
     Relations.toMany(() => FFAuthUserSession, 'userId')
 ], FFAuthUser.prototype, "sessions", void 0);
 FFAuthUser = __decorate([
-    Entity('ff_auth.users', {
+    FF_Entity('ff_auth.users', {
         allowApiCrud: [FF_Auth_Role.Admin, FF_Role.Admin],
-        caption: 'Auth - Users',
+        caption: 'FF Auth - Users',
     })
 ], FFAuthUser);
 export { FFAuthUser };
@@ -107,10 +117,15 @@ __decorate([
     Fields.date({ includeInApi: false, allowNull: true })
 ], FFAuthAccount.prototype, "lastVerifiedAt", void 0);
 FFAuthAccount = __decorate([
-    Entity('ff_auth.accounts', {
+    FF_Entity('ff_auth.accounts', {
         allowApiCrud: [FF_Auth_Role.Admin, FF_Role.Admin],
-        caption: 'Auth - Accounts',
+        caption: 'FF Auth - Accounts',
         // id: { provider: true, userId: true },
+        changeLog: {
+            excludeColumns: (e) => {
+                return [e.hashPassword, e.token];
+            },
+        },
     })
 ], FFAuthAccount);
 export { FFAuthAccount };
@@ -133,9 +148,10 @@ __decorate([
     Relations.toOne(() => FFAuthUser, 'userId')
 ], FFAuthUserSession.prototype, "user", void 0);
 FFAuthUserSession = __decorate([
-    Entity('ff_auth.users_sessions', {
+    FF_Entity('ff_auth.users_sessions', {
         allowApiCrud: [FF_Auth_Role.Admin, FF_Role.Admin],
-        caption: 'Auth - Users sessions',
+        caption: 'FF Auth - Users sessions',
+        changeLog: false,
     })
 ], FFAuthUserSession);
 export { FFAuthUserSession };

package/esm/auth/client/index.d.ts

@@ -1,2 +1,7 @@
+import { Log } from '@kitql/helpers';
 import { Auth } from './Auth';
+import { FFAuthAccount, FFAuthProvider, FFAuthUser, FFAuthUserSession } from './Entities';
+export declare const logAuth: Log;
+export { FF_Auth_Role } from './Entities';
 export { Auth };
+export { FFAuthUser, FFAuthAccount, FFAuthProvider, FFAuthUserSession };

package/esm/auth/client/index.js

@@ -1,2 +1,7 @@
+import { Log } from '@kitql/helpers';
 import { Auth } from './Auth';
+import { FFAuthAccount, FFAuthProvider, FFAuthUser, FFAuthUserSession } from './Entities';
+export const logAuth = new Log('firstly | auth');
+export { FF_Auth_Role } from './Entities';
 export { Auth };
+export { FFAuthUser, FFAuthAccount, FFAuthProvider, FFAuthUserSession };

package/esm/auth/helper.d.ts

@@ -1 +1,6 @@
-export declare function createSession(userId: string): Promise<void>;
+import type { Session } from 'lucia';
+/**
+ * Create or extend a session for a user.
+ * If you pass a session, it will extend it.
+ */
+export declare function createOrExtendSession(userId: string, session?: Session): Promise<void>;

package/esm/auth/helper.js

@@ -1,7 +1,14 @@
 import { remult } from 'remult';
 import { lucia } from '.';
-export async function createSession(userId) {
-    const session = await lucia.createSession(userId, {});
-    const sessionCookie = lucia.createSessionCookie(session.id);
-    remult.context.setCookie(sessionCookie.name, sessionCookie.value, { path: '/' });
+/**
+ * Create or extend a session for a user.
+ * If you pass a session, it will extend it.
+ */
+export async function createOrExtendSession(userId, session) {
+    const sessionToUser = session ? session : await lucia.createSession(userId, {});
+    const sessionCookie = lucia.createSessionCookie(sessionToUser.id);
+    remult.context.setCookie(sessionCookie.name, sessionCookie.value, {
+        path: '/',
+        ...sessionCookie.attributes,
+    });
 }

package/esm/auth/index.d.ts

@@ -1,21 +1,17 @@
 import type { OAuth2Provider as ArcticOAuth2Provider, OAuth2ProviderWithPKCE as ArcticOAuth2ProviderWithPKCE } from 'arctic';
 import { Lucia, type SessionCookieOptions } from 'lucia';
 import type { ClassType, UserInfo } from 'remult';
-import { Log } from '@kitql/helpers';
 import type { Module } from '../api';
 import type { RecursivePartial, ResolvedType } from '../utils/types';
-import { FFAuthAccount, FFAuthProvider, FFAuthUser, FFAuthUserSession } from './Entities';
+import { FFAuthAccount, FFAuthUser, FFAuthUserSession } from './client/Entities';
 import type { firstlyData, firstlyDataAuth } from './types';
 export type { firstlyData };
-export { FFAuthUser, FFAuthAccount, FFAuthProvider, FFAuthUserSession };
 export type AuthorizationURLOptions = Record<string, {
     scopes?: string[];
 }>;
 export type DynamicAuthorizationURLOptions<T extends FFOAuth2Provider[] = FFOAuth2Provider[]> = T extends Array<infer O> ? O extends FFOAuth2Provider ? {
     [P in O['name']]: ReturnType<O['authorizationURLOptions']>;
 } : never : never;
-export declare const logAuth: Log;
-export { FF_Auth_Role } from './Entities';
 type OAuth2UserInfo = {
     raw?: any;
     providerUserId: string;
@@ -37,7 +33,9 @@ type AuthOptions<TUserEntity extends FFAuthUser = FFAuthUser, TSessionEntity ext
     };
     debug?: boolean;
     ui?: false | RecursivePartial<firstlyDataAuth['ui']>;
-    /** in secondes @default 15 days */
+    /** Usefull to overwrite where the static files are */
+    uiStaticPath?: string;
+    /** in secondes @default 30 days */
     sessionExpiresIn?: number;
     sessionCookie?: SessionCookieOptions;
     defaultRedirect?: string;
@@ -61,6 +59,7 @@ type AuthOptions<TUserEntity extends FFAuthUser = FFAuthUser, TSessionEntity ext
         email: string;
         url: string;
     }) => Promise<void>;
+    transformDbUserToClientUser?: (session: any, user: TUserEntity) => DatabaseUserAttributes;
     providers?: {
         demo?: {
             name: string;
@@ -122,13 +121,15 @@ export declare const getSafeOptions: () => {
     verifiedMethod: "email" | "auto" | "manual";
     redirectUrl: string;
     firstlyData: firstlyData;
+    transformDbUserToClientUser: (session: any, user: FFAuthUser) => DatabaseUserAttributes;
+    uiStaticPath: string;
 };
 /**
  * To enable authentication in your app in a few lines of code.
  * _Info: index: -777_
  */
 export declare const auth: (o: AuthOptions) => Module;
-export declare const lucia: Lucia<Record<any, any>, UserInfo>;
+export declare let lucia: Lucia<Record<any, any>, UserInfo>;
 declare module 'lucia' {
     interface Register {
         Lucia: typeof lucia;
@@ -138,10 +139,7 @@ declare module 'lucia' {
     interface DatabaseSessionAttributes {
     }
 }
-interface DatabaseUserAttributes {
-    id: string;
-    name: string;
-    roles: string[];
+interface DatabaseUserAttributes extends UserInfo {
     session: {
         id: string;
         expiresAt: Date;

package/esm/auth/index.js

@@ -2,33 +2,29 @@ import { redirect } from '@sveltejs/kit';
 import { DEV } from 'esm-env';
 import { Lucia, TimeSpan } from 'lucia';
 import { remult } from 'remult';
-import { Log, red } from '@kitql/helpers';
+import { red } from '@kitql/helpers';
 import { getRelativePackagePath, read } from '@kitql/internals';
 import { env } from '$env/dynamic/private';
 import { FF_Role } from '../';
 import { RemultLuciaAdapter } from './Adapter';
 import { AuthControllerServer } from './AuthController.server';
-import { Auth } from './client';
-import { FF_Auth_Role, FFAuthAccount, FFAuthProvider, FFAuthUser, FFAuthUserSession, } from './Entities';
-import { createSession } from './helper';
+import { Auth, logAuth } from './client';
+import { FF_Auth_Role, FFAuthAccount, FFAuthProvider, FFAuthUser, FFAuthUserSession, } from './client/Entities';
+import { createOrExtendSession } from './helper';
 import { initRoleFromEnv } from './RoleHelpers';
-export { FFAuthUser, FFAuthAccount, FFAuthProvider, FFAuthUserSession };
-export const logAuth = new Log('firstly | auth');
-export { FF_Auth_Role } from './Entities';
 export let AUTH_OPTIONS = { ui: {} };
 const buildUrlOrDefault = (base, userSetting, fallback) => {
-    if (userSetting) {
-        return `${base}/${userSetting}`;
+    if (userSetting === false) {
+        return false;
     }
-    return `${base}/${fallback}`;
+    if (userSetting === undefined) {
+        return `${base}/${fallback}`;
+    }
+    return `${base}/${userSetting}`;
 };
 export const getSafeOptions = () => {
     const signUp = AUTH_OPTIONS.signUp ?? true;
     const base = AUTH_OPTIONS.ui === false ? 'NO_BASE_PATH' : AUTH_OPTIONS.ui?.paths?.base ?? '/ff/auth';
-    // const oAuths =
-    //   AUTH_OPTIONS.providers?.oAuths?.map((o) => {
-    //     return o.name
-    //   }) ?? []
     const firstlyData = {
         module: 'auth',
         debug: AUTH_OPTIONS.debug,
@@ -48,6 +44,8 @@ export const getSafeOptions = () => {
                         email: AUTH_OPTIONS.ui?.strings?.email ?? 'Email',
                         email_placeholder: AUTH_OPTIONS.ui?.strings?.email_placeholder ?? 'Your email address',
                         password: AUTH_OPTIONS.ui?.strings?.password ?? 'Password',
+                        confirm: AUTH_OPTIONS.ui?.strings?.confirm ?? 'Confirm',
+                        reset: AUTH_OPTIONS.ui?.strings?.reset ?? 'Reset',
                         btn_sign_up: AUTH_OPTIONS.ui?.strings?.btn_sign_up ?? 'Sign up',
                         btn_sign_in: AUTH_OPTIONS.ui?.strings?.btn_sign_in ?? 'Sign in',
                         forgot_password: AUTH_OPTIONS.ui?.strings?.forgot_password ?? 'Forgot your password?',
@@ -58,11 +56,45 @@ export const getSafeOptions = () => {
                 },
         },
     };
+    let uiStaticPath = AUTH_OPTIONS.uiStaticPath ?? '';
+    if (!AUTH_OPTIONS.uiStaticPath) {
+        const installedFirstlyPath = getRelativePackagePath('firstly');
+        if (installedFirstlyPath) {
+            uiStaticPath = `${installedFirstlyPath}/esm/auth/static/`;
+        }
+    }
     let redirectUrl = AUTH_OPTIONS.defaultRedirect ?? '/';
     if (!redirectUrl.startsWith('/')) {
         logAuth.error(`Invalid redirect url ${red(redirectUrl)} (it should be a local one starting with /)`);
         redirectUrl = '/';
     }
+    let transformDbUserToClientUserToUse;
+    if (AUTH_OPTIONS.transformDbUserToClientUser) {
+        transformDbUserToClientUserToUse = AUTH_OPTIONS.transformDbUserToClientUser;
+    }
+    else {
+        // Need in src/app.d.ts this code to be able to have the correct transformDbUserToClientUser returned type.
+        // In the lib, let's force to this default
+        /**
+         * declare module 'remult' {
+         *   export interface UserInfo {
+         *     specificThing: string
+         *   }
+         * }
+         */
+        // @ts-ignore
+        transformDbUserToClientUserToUse = (session, user) => {
+            return {
+                id: user.id,
+                name: user.identifier,
+                roles: user.roles,
+                session: {
+                    id: session.id,
+                    expiresAt: session.expiresAt,
+                },
+            };
+        };
+    }
     return {
         User: AUTH_OPTIONS.customEntities?.User ?? FFAuthUser,
         Session: AUTH_OPTIONS.customEntities?.Session ?? FFAuthUserSession,
@@ -73,6 +105,8 @@ export const getSafeOptions = () => {
         verifiedMethod: AUTH_OPTIONS.verifiedMethod ?? 'auto',
         redirectUrl,
         firstlyData,
+        transformDbUserToClientUser: transformDbUserToClientUserToUse,
+        uiStaticPath,
     };
 };
 /**
@@ -93,6 +127,23 @@ export const auth = (o) => {
     Auth.signInOTPFn = AuthControllerServer.signInOTP;
     Auth.verifyOtpFn = AuthControllerServer.verifyOtp;
     Auth.signInOAuthGetUrlFn = AuthControllerServer.signInOAuthGetUrl;
+    const adapter = new RemultLuciaAdapter();
+    const defaultExpiresIn = 60 * 60 * 24 * 30; // 30 days
+    const sessionExpiresIn = new TimeSpan(AUTH_OPTIONS.sessionExpiresIn ?? defaultExpiresIn, 's');
+    lucia = new Lucia(adapter, {
+        sessionExpiresIn,
+        sessionCookie: {
+            name: AUTH_OPTIONS.sessionCookie?.name ?? 'firstly_auth_session',
+            expires: AUTH_OPTIONS.sessionCookie?.expires,
+            attributes: {
+                // set to `true` when using HTTPS
+                secure: !DEV,
+                ...AUTH_OPTIONS.sessionCookie?.attributes,
+            },
+        },
+        getSessionAttributes: (attributes) => attributes,
+        getUserAttributes: (attributes) => attributes,
+    });
     return {
         name: 'auth',
         index: -777,
@@ -104,19 +155,12 @@ export const auth = (o) => {
             if (sessionId) {
                 const { session, user } = await lucia.validateSession(sessionId);
                 if (session && session.fresh) {
-                    const sessionCookie = lucia.createSessionCookie(session.id);
-                    event.cookies.set(sessionCookie.name, sessionCookie.value, {
-                        path: '/',
-                        ...sessionCookie.attributes,
-                    });
+                    await createOrExtendSession(session.id, session);
                 }
                 remult.user = user ?? undefined;
             }
         },
         earlyReturn: async ({ event, resolve }) => {
-            // if (AUTH_OPTIONS.ui === false) {
-            //   return { early: false }
-            // }
             const oSafe = getSafeOptions();
             if (event.url.pathname === oSafe.firstlyData.props.ui?.paths?.verify_email) {
                 const token = event.url.searchParams.get('token') ?? '';
@@ -138,19 +182,12 @@ export const auth = (o) => {
                 account.expiresAt = undefined;
                 account.lastVerifiedAt = new Date();
                 await remult.repo(oSafe.Account).save(account);
-                await createSession(account.userId);
+                await createOrExtendSession(account.userId);
                 redirect(302, oSafe.redirectUrl);
             }
-            // For lib author (us), it's good to have this local path.
-            let staticPath = './src/lib/auth/static/';
-            // For users, let's serve the static files from the installed package
-            const installedFirstlyPath = getRelativePackagePath('firstly');
-            if (installedFirstlyPath) {
-                staticPath = `${installedFirstlyPath}/esm/auth/static/`;
-            }
             if (oSafe.firstlyData.props.ui?.paths?.base &&
                 event.url.pathname.startsWith(oSafe.firstlyData.props.ui.paths.base)) {
-                const content = read(`${staticPath}index.html`);
+                const content = read(`${oSafe.uiStaticPath}index.html`);
                 return {
                     early: true,
                     resolve: new Response(content + `<script>const firstlyData = ${JSON.stringify(oSafe.firstlyData)}</script>`, {
@@ -159,7 +196,7 @@ export const auth = (o) => {
                 };
             }
             if (event.url.pathname.startsWith('/api/static')) {
-                const content = read(`${staticPath}${event.url.pathname.replaceAll('/api/static/', '')}`);
+                const content = read(`${oSafe.uiStaticPath}${event.url.pathname.replaceAll('/api/static/', '')}`);
                 if (content) {
                     const seg = event.url.pathname.split('.');
                     const map = {
@@ -223,7 +260,7 @@ export const auth = (o) => {
                         for (let i = 0; i < info.nameOptions.length; i++) {
                             const existingUser = await remult
                                 .repo(oSafe.User)
-                                .findOne({ where: { name: info.nameOptions[i] } });
+                                .findOne({ where: { identifier: info.nameOptions[i] } });
                             if (existingUser) {
                                 // Don't do anything
                             }
@@ -236,7 +273,7 @@ export const auth = (o) => {
                             nameToUse = `${info.nameOptions[0]}-${info.providerUserId}`;
                         }
                         const user = remult.repo(oSafe.User).create();
-                        user.name = nameToUse;
+                        user.identifier = nameToUse;
                         account = remult.repo(oSafe.Account).create();
                         account.provider = keyState;
                         account.providerUserId = info.providerUserId;
@@ -250,7 +287,7 @@ export const auth = (o) => {
                         account.token = tokens.accessToken;
                         await remult.repo(oSafe.Account).save(account);
                     }
-                    await createSession(account.userId);
+                    await createOrExtendSession(account.userId);
                     event.cookies.delete(`${keyState}_oauth_state`, { path: '/' });
                     event.cookies.delete(`code_verifier`, { path: '/' });
                 }
@@ -264,38 +301,5 @@ export const auth = (o) => {
         },
     };
 };
-const adapter = new RemultLuciaAdapter();
-const defaultExpiresIn = 60 * 60 * 24 * 15; // 15 days
-export const lucia = new Lucia(adapter, {
-    sessionExpiresIn: new TimeSpan(AUTH_OPTIONS.sessionExpiresIn ?? defaultExpiresIn, 's'),
-    sessionCookie: {
-        name: AUTH_OPTIONS.sessionCookie?.name ?? 'remult_auth_session',
-        expires: AUTH_OPTIONS.sessionCookie?.expires,
-        attributes: {
-            // set to `true` when using HTTPS
-            secure: !DEV,
-            ...AUTH_OPTIONS.sessionCookie?.attributes,
-        },
-    },
-    getSessionAttributes: (attributes) => {
-        return {
-            ...attributes,
-        };
-    },
-    getUserAttributes(attributes) {
-        // @ts-expect-error
-        delete attributes['createdAt'];
-        // @ts-expect-error
-        delete attributes['updatedAt'];
-        // to remove relations
-        for (const key in attributes) {
-            if (attributes[key] === undefined) {
-                delete attributes[key];
-            }
-        }
-        return attributes;
-        // return {
-        // 	...attributes,
-        // }
-    },
-});
+// Maybe moving this to /auth/server.ts would be better, people will be able to import from firstly all the time
+export let lucia;

package/esm/auth/providers/github.js

@@ -2,7 +2,8 @@ import { GitHub } from 'arctic';
 import { remult } from 'remult';
 import { env } from '$env/dynamic/private';
 import { checkOAuthConfig } from '.';
-import { logAuth } from '../';
+import {} from '../';
+import { logAuth } from '../client';
 //------------------------------
 // For developers (future me ?), To do another OAuth2 provider:
 // Replace GITHUB / Github / github

package/esm/auth/providers/index.js

@@ -1,6 +1,6 @@
 import { cyan, gray, green, italic, yellow } from '@kitql/helpers';
-import { logAuth } from '..';
 import { mask } from '../../formats/strings';
+import { logAuth } from '../client';
 export const checkOAuthConfig = (name, clientId, secret, urlForKeys, withThrow) => {
     if (!clientId || !secret) {
         const msg = `Wrong configuration for ${green(name)} provider.

package/esm/auth/providers/strava.js

@@ -2,7 +2,8 @@ import { Strava } from 'arctic';
 import { remult } from 'remult';
 import { env } from '$env/dynamic/private';
 import { checkOAuthConfig } from '.';
-import { logAuth } from '../';
+import {} from '../';
+import { logAuth } from '../client';
 /**
  * ## Strava OAuth2 provider
  *

package/esm/auth/static/assets/{Page-RIbXHuZG.d.ts → Page-BEFYPjis.d.ts}

@@ -1,4 +1,4 @@
 export { v as default };
 declare class v extends l {
 }
-import { S as l } from "./index-qfq98Nyd.js";
+import { S as l } from "./index-QypqCYwC.js";

package/esm/auth/static/assets/{Page-RIbXHuZG.js → Page-BEFYPjis.js}

@@ -1 +1 @@
-import{S as l,b as d,a as f,d as i,h as m,M as p,t as u,n as r,z as h}from"./index-qfq98Nyd.js";function c(s){let e;const n={c:function(){e=p("Hello from admin")},l:function(t){throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option")},m:function(t,o){u(t,e,o)},p:r,i:r,o:r,d:function(t){t&&h(e)}};return i("SvelteRegisterBlock",{block:n,id:c.name,type:"component",source:"",ctx:s}),n}function w(s,e){let{$$slots:n={},$$scope:a}=e;m("Page",n,[]);const t=[];return Object.keys(e).forEach(o=>{!~t.indexOf(o)&&o.slice(0,2)!=="$$"&&o!=="slot"&&console.warn(`<Page> was created with unknown prop '${o}'`)}),[]}class v extends l{constructor(e){super(e),d(this,e,w,c,f,{}),i("SvelteRegisterComponent",{component:this,tagName:"Page",options:e,id:c.name})}}export{v as default};
+import{S as l,b as d,a as f,d as i,h as m,M as p,t as u,n as r,z as h}from"./index-QypqCYwC.js";function c(s){let e;const n={c:function(){e=p("Hello from admin")},l:function(t){throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option")},m:function(t,o){u(t,e,o)},p:r,i:r,o:r,d:function(t){t&&h(e)}};return i("SvelteRegisterBlock",{block:n,id:c.name,type:"component",source:"",ctx:s}),n}function w(s,e){let{$$slots:n={},$$scope:a}=e;m("Page",n,[]);const t=[];return Object.keys(e).forEach(o=>{!~t.indexOf(o)&&o.slice(0,2)!=="$$"&&o!=="slot"&&console.warn(`<Page> was created with unknown prop '${o}'`)}),[]}class v extends l{constructor(e){super(e),d(this,e,w,c,f,{}),i("SvelteRegisterComponent",{component:this,tagName:"Page",options:e,id:c.name})}}export{v as default};

package/esm/auth/static/assets/Page-Cfysx_UV.d.ts

@@ -0,0 +1,6 @@
+export { Ca as default };
+declare class Ca extends Ye {
+    set firstlyData(e: void);
+    get firstlyData(): void;
+}
+import { S as Ye } from "./index-QypqCYwC.js";