@aerogel/plugin-local-first 0.0.0-next.4c77ee2164e8a4f72bdd920cb56ec059299ccc5f

package/dist/InruptAuthenticator.lazy-BvpQLGoj-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-BvpQLGoj.js.map

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

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

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

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

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

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

package/dist/aerogel-plugin-local-first.d.ts

@@ -0,0 +1,269 @@
+import { Authenticator } from '@aerogel/plugin-solid';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { Cr } from '@noeldemartin/utils';
+import { DefineComponent } from 'vue';
+import { Engine } from 'soukai';
+import { ErrorSource } from '@aerogel/core';
+import { Facade } from '@noeldemartin/utils';
+import { Job } from '@aerogel/core';
+import { JobListener } from '@aerogel/core';
+import { JobStatus } from '@aerogel/core';
+import { Nullable } from '@noeldemartin/utils';
+import { ObjectsMap } from '@noeldemartin/utils';
+import { Plugin as Plugin_2 } from '@aerogel/core';
+import { PublicProps } from 'vue';
+import { Replace } from '@aerogel/core';
+import { Semaphore } from '@noeldemartin/utils';
+import { ServiceWithState } from '@aerogel/core';
+import { SolidContainer } from 'soukai-solid';
+import { SolidDocument } from 'soukai-solid';
+import { SolidModel } from 'soukai-solid';
+import { SolidModelConstructor } from 'soukai-solid';
+import { SolidSchemaDefinition } from 'soukai-solid';
+import { SolidTypeIndex } from 'soukai-solid';
+import { Tombstone } from 'soukai-solid';
+
+export declare const AGCloudStatus: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+sync: (...args: any[]) => void;
+}, string, PublicProps, Readonly<{}> & Readonly<{
+onSync?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
+
+export declare const Cloud: Facade<CloudService>;
+
+export declare class CloudService extends _default {
+    protected asyncLock: Semaphore;
+    protected engine: Engine | null;
+    protected pollingInterval: NodeJS.Timeout | null;
+    whenReady<T>(callback: () => T): Promise<T>;
+    setup(modelUrlMappings?: WeakMap<SolidModelConstructor, Record<string, string>>): Promise<void>;
+    dismissSetup(): void;
+    dismissMigration(): void;
+    postponeMigration(): void;
+    syncIfOnline(options?: SyncOptions): Promise<void>;
+    syncIfOnline(model: SolidModel): Promise<void>;
+    syncIfOnline(models: SolidModel[]): Promise<void>;
+    sync(options?: SyncOptions): Promise<void>;
+    sync(model: SolidModel): Promise<void>;
+    sync(models: SolidModel[]): Promise<void>;
+    shouldMigrate(): boolean;
+    migrate(listener?: JobListener): Promise<void>;
+    register(modelClass: SolidModelConstructor, options?: RegisterOptions): Promise<void>;
+    registerSchemaMigration(modelClass: SolidModelConstructor, schema: SolidModelConstructor | SolidSchemaDefinition): void;
+    requireRemoteCollection(modelClass: SolidModelConstructor): string;
+    protected boot(): Promise<void>;
+    protected getDirtyLocalModels(): SolidModel[];
+    protected getModelsIn(urls: string[], model: SolidModel): SolidModel[];
+    protected requireEngine(): Engine;
+    protected setReady(ready: boolean): Promise<void>;
+    protected backup(modelUrlMappings?: WeakMap<SolidModelConstructor, Record<string, string>>): Promise<void>;
+    protected onApplicationReady(): Promise<void>;
+    protected onApplicationMounted(): Promise<void>;
+    protected login(authenticator: Authenticator): void;
+    protected logout(): void;
+    private syncOnStartup;
+}
+
+declare const CloudStatus: {
+    readonly Disconnected: "disconnected";
+    readonly Online: "online";
+    readonly Syncing: "syncing";
+    readonly Migrating: "migrating";
+};
+
+declare const _default: ServiceWithState<    {
+autoPush: boolean;
+localModelUpdates: Record<string, number>;
+migrationDismissed: boolean;
+migrationJob: Nullable<Migrate>;
+migrationPostponed: boolean;
+modelCollections: Record<string, string[]>;
+pollingEnabled: boolean;
+pollingMinutes: number;
+ready: boolean;
+registeredModels: ModelRegistration[];
+schemaMigrations: Map<SolidModelConstructor, SolidModelConstructor | SolidSchemaDefinition>;
+setupDismissed: boolean;
+setupOngoing: boolean;
+startupSync: boolean;
+status: TCloudStatus;
+syncError: Nullable<ErrorSource>;
+syncJob: Nullable<Sync>;
+}, {
+disconnected: boolean;
+online: boolean;
+syncing: boolean;
+migrating: boolean;
+localChanges: number;
+dirty: boolean;
+migrationStarted: boolean;
+migrationDisabledReason: string | null;
+}, Replace<Partial<{
+autoPush: boolean;
+localModelUpdates: Record<string, number>;
+migrationDismissed: boolean;
+migrationJob: Nullable<Migrate>;
+migrationPostponed: boolean;
+modelCollections: Record<string, string[]>;
+pollingEnabled: boolean;
+pollingMinutes: number;
+ready: boolean;
+registeredModels: ModelRegistration[];
+schemaMigrations: Map<SolidModelConstructor, SolidModelConstructor | SolidSchemaDefinition>;
+setupDismissed: boolean;
+setupOngoing: boolean;
+startupSync: boolean;
+status: TCloudStatus;
+syncError: Nullable<ErrorSource>;
+syncJob: Nullable<Sync>;
+}>, {
+migrationJob: MigrateJobStatus | undefined;
+}>>;
+
+declare class LoadsChildren {
+    protected localModels?: ObjectsMap<SolidModel>;
+    protected loadContainedModels(model: SolidContainer, options?: {
+        ignoreTombstones?: boolean;
+        status?: ResourceJobStatus;
+        onLoaded?: (urls: string[]) => unknown;
+        onMalformedDocument?: (url: string) => unknown;
+    }): Promise<SolidModel[]>;
+    protected loadDocumentChildren(model: SolidModel, documentUrl: string, documents: ObjectsMap<SolidDocument>, onMalformedDocument?: (url: string) => unknown): Promise<{
+        children: Record<string, SolidModel[]>;
+        tombstones: Tombstone[];
+    }>;
+    protected loadDocumentChildrenFromLocal(model: SolidModel, document: SolidDocument): Promise<Record<string, SolidModel[]>>;
+    protected loadDocumentChildrenFromRemote(model: SolidModel, documentUrl: string, onMalformedDocument?: (url: string) => unknown): Promise<{
+        children: Record<string, SolidModel[]>;
+        tombstones: Tombstone[];
+    }>;
+}
+
+declare class LoadsTypeIndex {
+    protected loadTypeIndex(options: {
+        create: true;
+    }): Promise<SolidTypeIndex>;
+    protected loadTypeIndex(options?: {
+        create: false;
+    }): Promise<SolidTypeIndex | null>;
+}
+
+declare function localFirst(): Plugin_2;
+export default localFirst;
+
+export declare type LocalFirstServices = typeof services;
+
+declare class Migrate extends Migrate_base {
+    static restore(status: MigrateJobStatus): Migrate;
+    protected _models?: SolidModel[];
+    get models(): SolidModel[] | undefined;
+    set models(models: SolidModel[] | undefined);
+    protected run(): Promise<void>;
+    protected migrateRegisteredModel(model: SolidModel, status: MigrateModelJobStatus, typeIndex?: Nullable<SolidTypeIndex>): Promise<void>;
+    protected migrate(localModel: SolidModel, status: MigrateModelJobStatus): Promise<void>;
+    protected migrateChildren(localModel: SolidModel, status: MigrateModelJobStatus): Promise<void>;
+}
+
+declare const Migrate_base: typeof Job<JobListener, MigrateJobStatus, MigrateJobStatus> & Cr<LoadsChildren & LoadsTypeIndex & TracksLocalModels>;
+
+declare interface MigrateJobStatus extends JobStatus {
+    children?: MigrateModelJobStatus[];
+}
+
+declare interface MigrateModelJobStatus extends JobStatus {
+    modelUrl: string;
+    children?: MigrateModelJobStatus[];
+}
+
+declare interface ModelRegistration {
+    modelClass: SolidModelConstructor;
+    path?: string;
+}
+
+export declare interface RegisterOptions {
+    path?: string;
+}
+
+declare interface ResourceJobStatus extends JobStatus {
+    documentUrl?: string;
+    children?: ResourceJobStatus[];
+}
+
+declare const services: {
+    $cloud: Facade<CloudService>;
+};
+
+declare class Sync extends Sync_base {
+    protected models?: SolidModel[];
+    protected dirtyRemoteModels?: SolidModel[];
+    protected rootLocalModels: SolidModel[];
+    protected tombstones: ObjectsMap<Tombstone>;
+    protected malformedDocuments: Set<string>;
+    protected documentsModifiedAt: Record<string, Date>;
+    protected localModels: ObjectsMap<SolidModel>;
+    constructor(models?: SolidModel[]);
+    protected run(): Promise<void>;
+    protected getInitialStatus(): SyncJobStatus;
+    protected calculateCurrentProgress(status?: JobStatus): number;
+    private pullChanges;
+    private pushChanges;
+    private fetchRemoteModels;
+    private fetchRemoteModelsForLocal;
+    private updateTypeRegistrations;
+    private loadChildren;
+    private deleteChild;
+    private saveModelAndChildren;
+    private synchronizeModels;
+    private reconcileInconsistencies;
+    private synchronizeContainerDocuments;
+    private rememberModelDocuments;
+    private ignoringMalformedDocumentErrors;
+}
+
+declare const Sync_base: typeof Job<JobListener, SyncJobStatus, SyncJobStatus> & Cr<LoadsChildren & LoadsTypeIndex & TracksLocalModels>;
+
+declare interface SyncJobStatus extends JobStatus {
+    root: true;
+    children: [SyncPullJobStatus, JobStatus];
+}
+
+export declare interface SyncOptions extends JobListener {
+    refreshUserProfile?: boolean;
+    model?: SolidModel;
+    models?: SolidModel[];
+}
+
+declare interface SyncPullJobStatus extends JobStatus {
+    children?: ResourceJobStatus[];
+}
+
+declare type TCloudStatus = (typeof CloudStatus)[keyof typeof CloudStatus];
+
+declare class TracksLocalModels {
+    protected localModels?: ObjectsMap<SolidModel>;
+    protected indexLocalModels(models: SolidModel[]): Promise<void>;
+    protected addLocalModel(localModel: SolidModel): Promise<void>;
+}
+
+export { }
+
+
+declare module '@aerogel/core' {
+    interface Services extends LocalFirstServices {
+    }
+}
+
+
+declare module '@aerogel/core' {
+    interface EventsPayload {
+        'cloud:ready': void;
+        'cloud:backup-started': void;
+        'cloud:backup-completed': void;
+        'cloud:migration-started': SolidModel[];
+        'cloud:migration-cancelled': SolidModel[];
+        'cloud:migration-completed': SolidModel[];
+        'cloud:sync-started': SolidModel[] | undefined;
+        'cloud:sync-completed': SolidModel[] | undefined;
+    }
+}