@aerogel/plugin-solid 0.1.1 → 0.1.2-next.09ce77256b928c50029720116feccc246da1293c

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Noel De Martin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/InruptAuthenticator.lazy-DlPdapoE.js

@@ -0,0 +1,2 @@
+import { events as e, fetch as t, handleIncomingRedirect as n, login as r, logout as i } from "@inrupt/solid-client-authn-browser";
+export { e as events, t as fetch, n as handleIncomingRedirect, r as login, i as logout };

package/dist/LegacyAuthenticator.lazy-ghwPx9kV.js

@@ -0,0 +1,2 @@
+import e from "solid-auth-client";
+export { e as SolidAuthClient };

package/dist/{aerogel-plugin-solid.d.ts → index.d.ts}

@@ -1,28 +1,39 @@
 import { Closure } from '@noeldemartin/utils';
 import { ComponentOptionsMixin } from 'vue';
 import { ComponentProvideOptions } from 'vue';
+import { ComputedAttribute } from 'soukai-bis';
+import { ComputedRef } from 'vue';
+import { Container } from 'soukai-bis';
+import { ContainerConstructor } from 'soukai-bis';
 import { DefineComponent } from 'vue';
-import { Engine } from 'soukai';
+import { Engine } from 'soukai-bis';
 import { ErrorSource } from '@aerogel/core';
 import { Facade } from '@noeldemartin/utils';
-import { Fetch } from 'soukai-solid';
-import { Fetch as Fetch_2 } from '@noeldemartin/solid-utils';
+import { Fetch } from '@noeldemartin/solid-utils';
 import { FluentArray } from '@noeldemartin/utils';
-import { GetClosureArgs } from '@noeldemartin/utils';
 import { HTMLAttributes } from 'vue';
 import { JSError } from '@noeldemartin/utils';
 import { JSErrorOptions } from '@noeldemartin/utils';
+import { MaybeRefOrGetter } from 'vue';
+import { Model } from 'soukai-bis';
+import { ModelConstructor } from 'soukai-bis';
+import { ModelEvents } from 'soukai-bis';
+import { ModelListener } from 'soukai-bis';
+import { ModelsRegistry } from 'soukai-bis';
+import { ModelWithUrl } from 'soukai-bis';
+import { Nullable } from '@noeldemartin/utils';
 import { NullablePartial } from '@noeldemartin/utils';
 import { Plugin as Plugin_2 } from '@aerogel/core';
 import { PromisedValue } from '@noeldemartin/utils';
 import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { Service } from '@aerogel/core';
 import { ServiceWithState } from '@aerogel/core';
-import { SolidContainer } from 'soukai-solid';
-import { SolidEngine } from 'soukai-solid';
-import { SolidModelConstructor } from 'soukai-solid';
+import { SolidEngine } from 'soukai-bis';
 import { SolidStore } from '@noeldemartin/solid-utils';
-import { SolidTypeIndex } from 'soukai-solid';
 import { SolidUserProfile } from '@noeldemartin/solid-utils';
+import { TypeIndex } from 'soukai-bis';
+import { z } from 'zod';
 
 declare type __VLS_Props = {
     src: string;
@@ -50,7 +61,7 @@ export declare abstract class Authenticator {
     protected booted?: PromisedValue<void>;
     protected listeners: FluentArray<AuthenticatorListener>;
     protected _engine?: SolidEngine;
-    abstract login(loginUrl: string, user?: SolidUserProfile | null): Promise<AuthSession>;
+    abstract login(loginUrl: string, options?: AuthenticatorLoginOptions): Promise<AuthSession>;
     abstract logout(): Promise<void>;
     get engine(): Engine;
     getAuthenticatedFetch(): Fetch | null;
@@ -73,6 +84,10 @@ export declare interface AuthenticatorListener {
     onAuthenticatedFetchReady?: (fetch: Fetch) => Promise<void> | void;
 }
 
+export declare interface AuthenticatorLoginOptions {
+    user?: Nullable<SolidUserProfile>;
+}
+
 export declare type AuthenticatorName = keyof Authenticators;
 
 export declare interface Authenticators extends BaseAuthenticators {
@@ -92,22 +107,32 @@ export declare interface AuthSession {
 
 declare type BaseAuthenticators = typeof authenticators;
 
+export declare function computedModel<T>(compute: () => T): Readonly<Ref<T>>;
+
+export declare function computedModelAttribute<TModel extends Model, TAttribute extends string & keyof TModel>(model: MaybeRefOrGetter<TModel | null | undefined>, attribute: TAttribute): TModel[TAttribute] extends ComputedAttribute<infer T> ? Readonly<Ref<T | undefined>> : never;
+
+export declare function computedModels<T>(modelClass: ModelConstructor, compute: () => T, options?: ComputedModelsOptions): ComputedRef<T>;
+
+export declare interface ComputedModelsOptions {
+    watch?: string[];
+}
+
 export declare class ContainerAlreadyInUse extends JSError {
-    constructor(container: SolidContainer, options?: JSErrorOptions);
+    constructor(container: Container, options?: JSErrorOptions);
 }
 
 declare const _default: ServiceWithState<    {
 autoReconnect: boolean;
 dismissed: boolean;
 ignorePreviousSessionError: boolean;
-loginStartupError: ErrorSource | null;
+loginStartupError: ErrorSource;
 loginOngoing: boolean;
 preferredAuthenticator: AuthenticatorName | null;
 previousSession: {
 profile?: SolidUserProfile;
 authenticator: AuthenticatorName;
 loginUrl: string;
-error: ErrorSource | null;
+error: ErrorSource;
 } | null;
 profiles: Record<string, SolidUserProfile>;
 session: AuthSession | null;
@@ -116,20 +141,20 @@ staleProfiles: string[];
 }, {
 user: SolidUserProfile | null;
 authenticator: Authenticator | null;
-fetch: Fetch_2;
+fetch: Fetch;
 error: unknown;
 }, Partial<{
 autoReconnect: boolean;
 dismissed: boolean;
 ignorePreviousSessionError: boolean;
-loginStartupError: ErrorSource | null;
+loginStartupError: ErrorSource;
 loginOngoing: boolean;
 preferredAuthenticator: AuthenticatorName | null;
 previousSession: {
 profile?: SolidUserProfile;
 authenticator: AuthenticatorName;
 loginUrl: string;
-error: ErrorSource | null;
+error: ErrorSource;
 } | null;
 profiles: Record<string, SolidUserProfile>;
 session: AuthSession | null;
@@ -137,8 +162,14 @@ loginStale: boolean;
 staleProfiles: string[];
 }>>;
 
+export declare function findTrackedModel<T extends Model>(modelClass: ModelConstructor<T>, url: string): Promise<T | null>;
+
 export declare function getAuthenticator<T extends AuthenticatorName>(name: T): Authenticators[T];
 
+export declare function getTrackedModels<T extends Model>(modelClass: ModelConstructor<T>, options?: {
+    includeSoftDeleted?: boolean;
+}): T[];
+
 declare class InruptAuthenticator extends Authenticator {
     private _events;
     private _fetch;
@@ -152,41 +183,61 @@ declare class InruptAuthenticator extends Authenticator {
     protected initSession(webId: string): Promise<void>;
 }
 
+export declare function isTrackingModel(modelClass: ModelConstructor): boolean;
+
 declare class LegacyAuthenticator extends Authenticator {
     private store;
     constructor();
-    login(loginUrl: string, user?: SolidUserProfile | null): Promise<AuthSession>;
+    login(loginUrl: string, { user }?: AuthenticatorLoginOptions): 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;
+declare type ListenerEventPayload<Event extends ListenerEvent, Callback = AuthenticatorListener[Event]> = Callback extends Closure ? Parameters<Callback> : never;
+
+export declare function loadTrackedModels(modelClass: ModelConstructor): Promise<void>;
 
 export declare type LoginOptions = NullablePartial<{
     authenticator: AuthenticatorName;
     onError(error: ErrorSource): unknown;
     fallbackUrl: string;
     loading: boolean;
+    skipProfile?: boolean;
+    extra?: Record<string, unknown>;
+}>;
+
+declare function model<T extends keyof ModelsRegistry>(name: T): ModelsRegistry[T];
+
+declare function model<T extends ModelConstructor = ModelConstructor>(name: string): T;
+
+export declare type ModelService<TModel extends Model = Model, TKey extends string = string> = Service<{
+    [K in TKey]: TModel[];
 }>;
 
 export declare interface Options {
     autoReconnect?: boolean;
     authenticators?: Record<string, Authenticator>;
-    defaultAuthenticator?: AuthenticatorName;
-    onUserProfileLoaded?(user: SolidUserProfile, store: SolidStore): Promise<unknown> | unknown;
+    defaultAuthenticator?: AuthenticatorName | (() => AuthenticatorName);
+    onUserProfileLoaded?(user: SolidUserProfile, store: SolidStore): unknown;
 }
 
 export declare type ReconnectOptions = Omit<LoginOptions, 'authenticator'> & {
     force?: boolean;
 };
 
+export declare function refreshTrackedModels(modelClass: ModelConstructor): Promise<void>;
+
+export declare type RefValue<T> = T extends Ref<infer TValue> ? TValue : never;
+
 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: {
+export declare function resetModelsState(): void;
+
+export declare const services: {
     $solid: Facade<SolidService>;
 };
 
@@ -199,11 +250,14 @@ export default solid;
 
 export declare const SolidAvatar: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
 
+export declare function solidContainerUrl(): z.ZodString;
+
 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 {
+    private _engine?;
     isLoggedIn(): this is {
         session: AuthSession;
         user: SolidUserProfile;
@@ -216,6 +270,7 @@ export declare class SolidService extends _default {
         user: SolidUserProfile;
     };
     requireAuthenticator(): Authenticator;
+    requireEngine(): SolidEngine;
     requireUser(): SolidUserProfile;
     requireUserProfile(url: string): Promise<SolidUserProfile>;
     getUserProfile(url: string, options: Omit<UserProfileOptions, 'required'> & {
@@ -228,23 +283,24 @@ export declare class SolidService extends _default {
     logout(force?: boolean): Promise<void>;
     whenLoggedIn<T>(callback: (session: AuthSession) => T): Promise<T>;
     dismiss(): void;
-    findOrCreatePrivateTypeIndex(): Promise<SolidTypeIndex>;
+    findRegisteredContainer<T extends Container = Container>(modelClass: ModelConstructor, containerClass?: ContainerConstructor<T>): Promise<T | null>;
+    findTypeIndexes(): Promise<ModelWithUrl<TypeIndex>[]>;
+    findOrCreatePrivateTypeIndex(): Promise<ModelWithUrl<TypeIndex>>;
     findPrivateTypeIndex(options?: {
         fresh?: boolean;
-    }): Promise<SolidTypeIndex | null>;
-    findOrCreatePublicTypeIndex(): Promise<SolidTypeIndex>;
+    }): Promise<ModelWithUrl<TypeIndex> | null>;
     findPublicTypeIndex(options?: {
         fresh?: boolean;
-    }): Promise<SolidTypeIndex | null>;
+    }): Promise<ModelWithUrl<TypeIndex> | null>;
+    clearTypeIndexesCache(): void;
     createPrivateContainer(options: {
         url: string;
         name?: string;
-        registerFor?: SolidModelConstructor;
+        registerFor?: ModelConstructor;
         reuseExisting?: boolean;
-    }): Promise<SolidContainer>;
+    }): Promise<ModelWithUrl<Container>>;
     protected boot(): Promise<void>;
-    protected createPrivateTypeIndex(): Promise<SolidTypeIndex>;
-    createPublicTypeIndex(): Promise<SolidTypeIndex>;
+    protected createPrivateTypeIndex(): Promise<ModelWithUrl<TypeIndex>>;
     protected attemptLogin(loginUrl: string, options: LoginOptions): Promise<boolean>;
     private restorePreviousSession;
     private startupReconnect;
@@ -256,6 +312,45 @@ export declare class SolidService extends _default {
 
 export declare type SolidServices = typeof services;
 
+export declare type SolidTestingRuntime = typeof testingRuntime;
+
+declare namespace testingRuntime {
+    export {
+        model
+    }
+}
+export { testingRuntime }
+
+export declare interface TrackCollectionsOptions {
+    refresh?: boolean;
+}
+
+export declare function trackModels<TModel extends Model, TKey extends string>(modelClass: ModelConstructor<TModel>, options?: TrackOptions<TModel, TKey>): Promise<void>;
+
+export declare type TrackOptions<TModel extends Model = Model, TKey extends string = string> = {
+    service?: ModelService<TModel, TKey>;
+    property?: TKey;
+    transform?: (models: TModel[]) => TModel[];
+    depth?: number;
+    lazy?: boolean;
+    bypassServicesCheck?: boolean;
+} & {
+    [K in keyof ModelEvents]?: ModelListener<TModel, K>;
+};
+
+export declare function useModelEvent<TModel extends Model, TEvent extends keyof ModelEvents>(modelClass: ModelConstructor<TModel>, event: TEvent, listener: ModelListener<TModel, TEvent>): void;
+
+export declare function useModels<T extends Model>(modelClass: ModelConstructor<T>, options?: {
+    includeSoftDeleted?: boolean;
+    depth?: number;
+}): UseModelsResult<T>;
+
+export declare interface UseModelsResult<T extends Model> {
+    models: ComputedRef<T[]>;
+    loading: ComputedRef<boolean>;
+    refreshing: Readonly<Ref<boolean>>;
+}
+
 export declare type UserProfileOptions = NullablePartial<{
     required: boolean;
     markStale: boolean;
@@ -264,6 +359,12 @@ export declare type UserProfileOptions = NullablePartial<{
 export { }
 
 
+declare module '@aerogel/core' {
+    interface AerogelTestingRuntime extends SolidTestingRuntime {
+    }
+}
+
+
 declare module '@aerogel/core' {
     interface Services extends SolidServices {
     }
@@ -280,3 +381,10 @@ declare module '@aerogel/core' {
         'solid:user-profile-loaded': [SolidUserProfile, SolidStore];
     }
 }
+
+
+declare module '@aerogel/core' {
+    interface EventsPayload {
+        'solid:track-models': ModelConstructor;
+    }
+}