@aerogel/plugin-solid 0.0.1-next.0d1cf82f9dfbe1d3e7ec5644f85f97a43c8c2334

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

@@ -0,0 +1,309 @@
+import { Closure } from '@noeldemartin/utils';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { DefineComponent } from 'vue';
+import { Engine } from 'soukai';
+import { ErrorSource } from '@aerogel/core';
+import { ExtractPropTypes } from 'vue';
+import { Facade } 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 { JSError } from '@noeldemartin/utils';
+import { JSErrorOptions } from '@noeldemartin/utils';
+import { NullablePartial } from '@noeldemartin/utils';
+import { Plugin as Plugin_2 } from '@aerogel/core';
+import { PromisedValue } from '@noeldemartin/utils';
+import { PropType } from 'vue';
+import { PublicProps } from 'vue';
+import { ServiceWithState } from '@aerogel/core';
+import { SolidContainer } 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 { SolidUserProfile } from '@noeldemartin/solid-utils';
+
+declare const __VLS_component: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'login-stale'?(_: {}): any;
+        'login-ongoing'?(_: {}): any;
+        'logged-in'?(_: {
+            session: AuthSession;
+        }): any;
+        'logged-out'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare const AGSolidImage: DefineComponent<ExtractPropTypes<    {
+src: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
+src: {
+type?: PropType<string> | undefined;
+validator?(value: unknown): boolean;
+} & {
+required: true;
+};
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLImageElement>;
+
+export declare const AGSolidStatus: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+export declare const AGSolidUserAvatar: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+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;
+    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;
+    requireAuthenticatedFetch(): Fetch;
+    addListener(listener: AuthenticatorListener): () => void;
+    removeListener(listener: AuthenticatorListener): void;
+    boot(): Promise<void>;
+    protected abstract restoreSession(): Promise<void>;
+    protected initAuthenticatedFetch(fetch: Fetch): Promise<void>;
+    protected startSession(sessionData: Omit<AuthSession, 'authenticator'>): Promise<AuthSession>;
+    protected failSession(loginUrl: string, error: ErrorSource): Promise<void>;
+    protected endSession(): Promise<void>;
+    protected notifyListeners<Event extends ListenerEvent>(event: Event, ...payload: ListenerEventPayload<Event>): Promise<void>;
+}
+
+export declare interface AuthenticatorListener {
+    onSessionStarted?: (session: AuthSession) => Promise<void> | void;
+    onSessionFailed?: (loginUrl: string, error: ErrorSource) => Promise<void> | void;
+    onSessionEnded?: () => Promise<void> | void;
+    onAuthenticatedFetchReady?: (fetch: Fetch) => Promise<void> | void;
+}
+
+export declare type AuthenticatorName = keyof Authenticators;
+
+export declare interface Authenticators extends BaseAuthenticators {
+    default: Authenticator;
+}
+
+export declare const authenticators: {
+    inrupt: InruptAuthenticator;
+    legacy: LegacyAuthenticator;
+};
+
+export declare interface AuthSession {
+    user: SolidUserProfile;
+    loginUrl: string;
+    authenticator: Authenticator;
+}
+
+declare type BaseAuthenticators = typeof authenticators;
+
+export declare class ContainerAlreadyInUse extends JSError {
+    constructor(container: SolidContainer, options?: JSErrorOptions);
+}
+
+declare const _default: ServiceWithState<    {
+autoReconnect: boolean;
+dismissed: boolean;
+ignorePreviousSessionError: boolean;
+loginStartupError: ErrorSource | null;
+loginOngoing: boolean;
+preferredAuthenticator: AuthenticatorName | null;
+previousSession: {
+profile?: SolidUserProfile;
+authenticator: AuthenticatorName;
+loginUrl: string;
+error: ErrorSource | null;
+} | null;
+profiles: Record<string, SolidUserProfile>;
+session: AuthSession | null;
+loginStale: boolean;
+staleProfiles: string[];
+}, {
+user: SolidUserProfile | null;
+authenticator: Authenticator | null;
+fetch: Fetch_2;
+error: unknown;
+}, Partial<{
+autoReconnect: boolean;
+dismissed: boolean;
+ignorePreviousSessionError: boolean;
+loginStartupError: ErrorSource | null;
+loginOngoing: boolean;
+preferredAuthenticator: AuthenticatorName | null;
+previousSession: {
+profile?: SolidUserProfile;
+authenticator: AuthenticatorName;
+loginUrl: string;
+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;
+    private _handleIncomingRedirect;
+    login(loginUrl: string): Promise<AuthSession>;
+    logout(): Promise<void>;
+    protected restoreSession(): Promise<void>;
+    protected loginFromRedirect(): Promise<void>;
+    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>;
+};
+
+export declare function setDefaultAuthenticator(authenticator: Authenticator): void;
+
+export declare const Solid: Facade<SolidService>;
+
+declare function solid(options?: Options): Plugin_2;
+export default solid;
+
+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, options: Omit<UserProfileOptions, 'required'> & {
+        required: true;
+    }): Promise<SolidUserProfile>;
+    getUserProfile(url: string, options?: UserProfileOptions): Promise<SolidUserProfile | null>;
+    refreshUserProfile(): 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(): Promise<SolidTypeIndex | null>;
+    findOrCreatePublicTypeIndex(): Promise<SolidTypeIndex>;
+    findPublicTypeIndex(): Promise<SolidTypeIndex | null>;
+    createPrivateContainer(options: {
+        url: string;
+        name?: string;
+        registerFor?: SolidModelConstructor;
+        reuseExisting?: boolean;
+    }): Promise<SolidContainer>;
+    protected boot(): Promise<void>;
+    protected createPrivateTypeIndex(): Promise<SolidTypeIndex>;
+    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 '@aerogel/core' {
+    interface Services extends SolidServices {
+    }
+}
+
+
+declare module '@aerogel/core' {
+    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];
+    }
+}