@aerogel/plugin-solid 0.0.1 → 0.1.0

package/dist/InruptAuthenticator.lazy-BvpQLGoj.js

@@ -0,0 +1,9 @@
+import { events as n, fetch as t, handleIncomingRedirect as c, login as g, logout as i } from "@inrupt/solid-client-authn-browser";
+export {
+  n as events,
+  t as fetch,
+  c as handleIncomingRedirect,
+  g as login,
+  i as logout
+};
+//# sourceMappingURL=InruptAuthenticator.lazy-BvpQLGoj.js.map

package/dist/InruptAuthenticator.lazy-BvpQLGoj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InruptAuthenticator.lazy-BvpQLGoj.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/LegacyAuthenticator.lazy-ChFFqP14.js

@@ -0,0 +1,5 @@
+import { default as l } from "solid-auth-client";
+export {
+  l as SolidAuthClient
+};
+//# sourceMappingURL=LegacyAuthenticator.lazy-ChFFqP14.js.map

package/dist/LegacyAuthenticator.lazy-ChFFqP14.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LegacyAuthenticator.lazy-ChFFqP14.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/aerogel-plugin-solid.d.ts

@@ -1,44 +1,56 @@
-import { AllowedComponentProps } from 'vue';
-import type { Closure } from '@noeldemartin/utils';
-import { ComponentCustomProps } from 'vue';
+import { Closure } from '@noeldemartin/utils';
 import { ComponentOptionsMixin } from 'vue';
-import { Constructor } from '@noeldemartin/utils';
+import { ComponentProvideOptions } from 'vue';
 import { DefineComponent } from 'vue';
-import type { Engine } from 'soukai';
-import type { ErrorSource } from '@aerogel/core';
-import { ExtractPropTypes } from 'vue';
+import { Engine } from 'soukai';
+import { ErrorSource } from '@aerogel/core';
 import { Facade } from '@noeldemartin/utils';
-import type { Fetch } from 'soukai-solid';
-import type { Fetch as Fetch_2 } from '@noeldemartin/solid-utils';
-import type { GetClosureArgs } from '@noeldemartin/utils';
+import { Fetch } from 'soukai-solid';
+import { Fetch as Fetch_2 } from '@noeldemartin/solid-utils';
+import { FluentArray } from '@noeldemartin/utils';
+import { GetClosureArgs } from '@noeldemartin/utils';
+import { HTMLAttributes } from 'vue';
 import { JSError } from '@noeldemartin/utils';
-import type { JSErrorOptions } from '@noeldemartin/utils';
-import type { Plugin as Plugin_2 } from '@aerogel/core';
+import { JSErrorOptions } from '@noeldemartin/utils';
+import { NullablePartial } from '@noeldemartin/utils';
+import { Plugin as Plugin_2 } from '@aerogel/core';
 import { PromisedValue } from '@noeldemartin/utils';
-import { RendererElement } from 'vue';
-import { RendererNode } from 'vue';
-import { Service } from '@aerogel/core';
+import { PublicProps } from 'vue';
+import { ServiceWithState } from '@aerogel/core';
 import { SolidContainer } from 'soukai-solid';
-import type { SolidModelConstructor } from 'soukai-solid';
+import { SolidEngine } from 'soukai-solid';
+import { SolidModelConstructor } from 'soukai-solid';
+import { SolidStore } from '@noeldemartin/solid-utils';
 import { SolidTypeIndex } from 'soukai-solid';
-import type { SolidUserProfile } from '@noeldemartin/solid-utils';
-import { VNode } from 'vue';
-import { VNodeProps } from 'vue';
+import { SolidUserProfile } from '@noeldemartin/solid-utils';
 
-export declare const AGSolidStatus: DefineComponent<    {}, (_ctx: any, _cache: any) => VNode<RendererNode, RendererElement, {
-[key: string]: any;
-}>, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;
+declare type __VLS_Props = {
+    src: string;
+};
+
+declare type __VLS_Props_2 = {
+    class?: HTMLAttributes['class'];
+    buttonClass?: HTMLAttributes['class'];
+    layout?: 'vertical' | 'horizontal';
+    noLoading?: boolean;
+    allowLegacyAuthenticator?: boolean;
+};
 
 export declare class AuthenticationCancelledError extends JSError {
 }
 
+export declare class AuthenticationFailedError extends JSError {
+    readonly description?: string | null;
+    constructor(message: string, description?: string | null, options?: JSErrorOptions);
+}
+
 export declare abstract class Authenticator {
     name: AuthenticatorName;
-    private authenticatedFetch?;
-    private booted?;
-    private listeners;
-    private _engine?;
-    abstract login(loginUrl: string, user?: SolidUserProfile): Promise<AuthSession>;
+    protected authenticatedFetch?: Fetch;
+    protected booted?: PromisedValue<void>;
+    protected listeners: FluentArray<AuthenticatorListener>;
+    protected _engine?: SolidEngine;
+    abstract login(loginUrl: string, user?: SolidUserProfile | null): Promise<AuthSession>;
     abstract logout(): Promise<void>;
     get engine(): Engine;
     getAuthenticatedFetch(): Fetch | null;
@@ -69,6 +81,7 @@ export declare interface Authenticators extends BaseAuthenticators {
 
 export declare const authenticators: {
     inrupt: InruptAuthenticator;
+    legacy: LegacyAuthenticator;
 };
 
 export declare interface AuthSession {
@@ -83,43 +96,17 @@ export declare class ContainerAlreadyInUse extends JSError {
     constructor(container: SolidContainer, options?: JSErrorOptions);
 }
 
-declare const _default: Constructor<    {
-autoReconnect: boolean;
-dismissed: boolean;
-ignorePreviousSessionError: boolean;
-loginError: unknown;
-loginOngoing: boolean;
-preferredAuthenticator: keyof Authenticators | null;
-previousSession: {
-authenticator: AuthenticatorName;
-loginUrl: string;
-avatarUrl?: string | undefined;
-error: ErrorSource | null;
-} | null;
-profiles: Record<string, SolidUserProfile>;
-session: AuthSession | null;
-loginStale: boolean;
-staleProfiles: string[];
-}> & Constructor<    {
-loggedIn: boolean;
-user: SolidUserProfile | null;
-userAvatarUrl: string | null;
-wasLoggedIn: boolean;
-authenticator: Authenticator | null;
-hasLoggedIn: boolean;
-fetch: Fetch_2;
-error: {} | null;
-}> & Constructor<Service<    {
+declare const _default: ServiceWithState<    {
 autoReconnect: boolean;
 dismissed: boolean;
 ignorePreviousSessionError: boolean;
-loginError: unknown;
+loginStartupError: ErrorSource | null;
 loginOngoing: boolean;
-preferredAuthenticator: keyof Authenticators | null;
+preferredAuthenticator: AuthenticatorName | null;
 previousSession: {
+profile?: SolidUserProfile;
 authenticator: AuthenticatorName;
 loginUrl: string;
-avatarUrl?: string | undefined;
 error: ErrorSource | null;
 } | null;
 profiles: Record<string, SolidUserProfile>;
@@ -127,40 +114,33 @@ session: AuthSession | null;
 loginStale: boolean;
 staleProfiles: string[];
 }, {
-loggedIn: boolean;
 user: SolidUserProfile | null;
-userAvatarUrl: string | null;
-wasLoggedIn: boolean;
 authenticator: Authenticator | null;
-hasLoggedIn: boolean;
 fetch: Fetch_2;
-error: {} | null;
+error: unknown;
 }, Partial<{
 autoReconnect: boolean;
 dismissed: boolean;
 ignorePreviousSessionError: boolean;
-loginError: unknown;
+loginStartupError: ErrorSource | null;
 loginOngoing: boolean;
-preferredAuthenticator: keyof Authenticators | null;
+preferredAuthenticator: AuthenticatorName | null;
 previousSession: {
+profile?: SolidUserProfile;
 authenticator: AuthenticatorName;
 loginUrl: string;
-avatarUrl?: string | undefined;
 error: ErrorSource | null;
 } | null;
 profiles: Record<string, SolidUserProfile>;
 session: AuthSession | null;
 loginStale: boolean;
 staleProfiles: string[];
-}>>>;
+}>>;
 
 export declare function getAuthenticator<T extends AuthenticatorName>(name: T): Authenticators[T];
 
-export declare interface IAGSolidStatusLoggedInSlotProps {
-    session: AuthSession;
-}
-
 declare class InruptAuthenticator extends Authenticator {
+    private _events;
     private _fetch;
     private _login;
     private _logout;
@@ -172,83 +152,131 @@ declare class InruptAuthenticator extends Authenticator {
     protected initSession(webId: string): Promise<void>;
 }
 
+declare class LegacyAuthenticator extends Authenticator {
+    private store;
+    constructor();
+    login(loginUrl: string, user?: SolidUserProfile | null): Promise<AuthSession>;
+    logout(): Promise<void>;
+    protected restoreSession(): Promise<void>;
+}
+
 declare type ListenerEvent = keyof AuthenticatorListener;
 
 declare type ListenerEventPayload<Event extends ListenerEvent, Callback = AuthenticatorListener[Event]> = Callback extends Closure ? GetClosureArgs<Callback> : never;
 
+export declare type LoginOptions = NullablePartial<{
+    authenticator: AuthenticatorName;
+    onError(error: ErrorSource): unknown;
+    fallbackUrl: string;
+    loading: boolean;
+}>;
+
 export declare interface Options {
+    autoReconnect?: boolean;
     authenticators?: Record<string, Authenticator>;
     defaultAuthenticator?: AuthenticatorName;
+    onUserProfileLoaded?(user: SolidUserProfile, store: SolidStore): Promise<unknown> | unknown;
 }
 
+export declare type ReconnectOptions = Omit<LoginOptions, 'authenticator'> & {
+    force?: boolean;
+};
+
 export declare function registerAuthenticator<T extends AuthenticatorName>(name: T, authenticator: Authenticators[T]): void;
 
 export declare function registerAuthenticators(customAuthenticators: Record<string, Authenticator>): void;
 
 declare const services: {
-    $solid: Facade<SolidService, Constructor<SolidService>>;
+    $solid: Facade<SolidService>;
 };
 
 export declare function setDefaultAuthenticator(authenticator: Authenticator): void;
 
-export declare const Solid: Facade<SolidService, Constructor<SolidService>>;
+export declare const Solid: Facade<SolidService>;
 
 declare function solid(options?: Options): Plugin_2;
 export default solid;
 
-declare class SolidService extends _default {
-    protected publicTypeIndexes: Record<string, PromisedValue<SolidTypeIndex>>;
-    protected privateTypeIndexes: Record<string, PromisedValue<SolidTypeIndex>>;
+export declare const SolidAvatar: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+export declare const SolidImage: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLImageElement>;
+
+export declare const SolidLogin: DefineComponent<__VLS_Props_2, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_2> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLFormElement>;
+
+export declare class SolidService extends _default {
     isLoggedIn(): this is {
         session: AuthSession;
         user: SolidUserProfile;
         authenticator: Authenticator;
     };
+    wasLoggedIn(): this is {
+        user: SolidUserProfile;
+    };
+    hasLoggedIn(): this is {
+        user: SolidUserProfile;
+    };
     requireAuthenticator(): Authenticator;
     requireUser(): SolidUserProfile;
     requireUserProfile(url: string): Promise<SolidUserProfile>;
-    getUserProfile(url: string, required: true): Promise<SolidUserProfile>;
-    getUserProfile(url: string, required?: false): Promise<SolidUserProfile | null>;
+    getUserProfile(url: string, options: Omit<UserProfileOptions, 'required'> & {
+        required: true;
+    }): Promise<SolidUserProfile>;
+    getUserProfile(url: string, options?: UserProfileOptions): Promise<SolidUserProfile | null>;
     refreshUserProfile(): Promise<void>;
-    login(loginUrl: string, authenticatorName?: AuthenticatorName): Promise<boolean>;
-    reconnect(force?: boolean): Promise<void>;
+    login(loginUrl: string, options?: LoginOptions): Promise<boolean>;
+    reconnect(options?: ReconnectOptions): Promise<void>;
     logout(force?: boolean): Promise<void>;
+    whenLoggedIn<T>(callback: (session: AuthSession) => T): Promise<T>;
     dismiss(): void;
     findOrCreatePrivateTypeIndex(): Promise<SolidTypeIndex>;
+    findPrivateTypeIndex(options?: {
+        fresh?: boolean;
+    }): Promise<SolidTypeIndex | null>;
     findOrCreatePublicTypeIndex(): Promise<SolidTypeIndex>;
+    findPublicTypeIndex(options?: {
+        fresh?: boolean;
+    }): Promise<SolidTypeIndex | null>;
     createPrivateContainer(options: {
         url: string;
-        name: string;
-        register?: {
-            typeIndex: SolidTypeIndex;
-            modelClass: SolidModelConstructor;
-        };
+        name?: string;
+        registerFor?: SolidModelConstructor;
         reuseExisting?: boolean;
     }): Promise<SolidContainer>;
     protected boot(): Promise<void>;
-    protected findPrivateTypeIndex(): Promise<SolidTypeIndex | null>;
     protected createPrivateTypeIndex(): Promise<SolidTypeIndex>;
-    protected findPublicTypeIndex(): Promise<SolidTypeIndex | null>;
     createPublicTypeIndex(): Promise<SolidTypeIndex>;
+    protected attemptLogin(loginUrl: string, options: LoginOptions): Promise<boolean>;
     private restorePreviousSession;
     private startupReconnect;
     private reconnectOnStartup;
+    private forcingReconnect;
     private bootAuthenticator;
     private rememberProfile;
 }
 
 export declare type SolidServices = typeof services;
 
+export declare type UserProfileOptions = NullablePartial<{
+    required: boolean;
+    markStale: boolean;
+}>;
+
 export { }
 
-declare module '@vue/runtime-core' {
-    interface ComponentCustomProperties extends SolidServices {}
+
+declare module '@aerogel/core' {
+    interface Services extends SolidServices {
+    }
 }
 
+
 declare module '@aerogel/core' {
-    export interface EventsPayload {
-        'authenticated-fetch-ready': Fetch;
-        login: AuthSession;
-        logout: void;
+    interface EventsPayload {
+        'auth:fetch-ready': Fetch;
+        'auth:before-login': void;
+        'auth:login': AuthSession;
+        'auth:logout': void;
+        'auth:after-logout': void;
+        'solid:user-profile-loaded': [SolidUserProfile, SolidStore];
     }
 }