@cratis/arc.react.mvvm 18.0.0

package/Bindings.ts

@@ -0,0 +1,18 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { container } from 'tsyringe';
+import { IMessenger, Messenger } from './messaging';
+import { Constructor } from '@cratis/fundamentals';
+import { ILocalStorage, INavigation, Navigation } from './browser';
+import { IdentityProvider, IIdentityProvider } from '@cratis/arc/identity';
+
+export class Bindings {
+    static initialize() {
+        container.registerSingleton(IMessenger as Constructor<IMessenger>, Messenger);
+        container.registerSingleton(INavigation as Constructor<INavigation>, Navigation);
+        container.registerSingleton(IIdentityProvider as Constructor<IIdentityProvider>, IdentityProvider);
+        container.registerInstance(ILocalStorage as Constructor<ILocalStorage>, localStorage);
+    }
+}
+

package/IHandleParams.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Represents a component that can handle parameters, typically a viewModel.
+ */
+export interface IHandleParams<T = object> {
+
+    /**
+     * Handle params.
+     * @param params Params to handle.
+     */
+    handleParams(params: T): void;
+}

package/IHandleProps.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Represents a component that can handle props, typically a viewModel.
+ */
+export interface IHandleProps<T = object> {
+
+    /**
+     * Handle props.
+     * @param props Props to handle.
+     */
+    handleProps(props: T): void;
+}

package/IHandleQueryParams.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Represents a component that can handle query parameters, typically a viewModel.
+ */
+export interface IHandleQueryParams<T = object> {
+
+    /**
+     * Handle query params.
+     * @param queryParams Query Params to handle.
+     */
+    handleQueryParams(queryParams: T): void;
+}

package/IViewModelDetached.ts

@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Represents the view model that is detached from the view. Use this to get the signature of the method that gets called when the view model is detached from the view.
+ */
+export interface IViewModelDetached {
+    /**
+     * Method that gets called when the view model is detached from the view.
+     */
+    detached(): void;
+}

package/MVVMContext.tsx

@@ -0,0 +1,27 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import React from 'react';
+import { Bindings } from './Bindings';
+import { configure as configureMobx } from 'mobx';
+import { MobxOptions } from './MobxOptions';
+
+export interface MVVMProps {
+    children?: JSX.Element | JSX.Element[];
+    mobx?: MobxOptions;
+}
+
+export const MVVMContext = React.createContext({});
+
+export const MVVM = (props: MVVMProps) => {
+    const options: MobxOptions = {
+        ...{ enforceActions: 'never' },
+        ...(props.mobx || {}),
+    };
+
+    configureMobx(options);
+
+    Bindings.initialize();
+
+    return <MVVMContext.Provider value={{}}>{props.children}</MVVMContext.Provider>;
+};

package/MobxOptions.ts

@@ -0,0 +1,20 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export interface MobxOptions {
+    enforceActions?: "never" | "always" | "observed";
+    computedRequiresReaction?: boolean;
+    /**
+     * Warn if you try to create to derivation / reactive context without accessing any observable.
+     */
+    reactionRequiresObservable?: boolean;
+    /**
+     * Warn if observables are accessed outside a reactive context
+     */
+    observableRequiresReaction?: boolean;
+    isolateGlobalState?: boolean;
+    disableErrorBoundaries?: boolean;
+    safeDescriptors?: boolean;
+    reactionScheduler?: (f: () => void) => void;
+    useProxies?: "always" | "never" | "ifavailable";
+}

package/README.md

@@ -0,0 +1,65 @@
+# Cratis Application Model
+
+## Packages / Deployables
+
+[![Nuget](https://img.shields.io/nuget/v/Cratis.Arc?logo=nuget)](http://nuget.org/packages/Cratis.Arc)
+[![NPM](https://img.shields.io/npm/v/@cratis/arc?label=@cratis/arc&logo=npm)](https://www.npmjs.com/package/@cratis/arc)
+
+## Builds
+
+[![.NET Build](https://github.com/cratis/arc/actions/workflows/dotnet-build.yml/badge.svg)](https://github.com/cratis/arc/actions/workflows/dotnet-build.yml)
+[![JavaScript Build](https://github.com/cratis/arc/actions/workflows/javascript-build.yml/badge.svg)](https://github.com/cratis/arc/actions/workflows/javascript-build.yml)
+[![Documentation site](https://github.com/Cratis/Documentation/actions/workflows/pages.yml/badge.svg)](https://github.com/Cratis/Documentation/actions/workflows/pages.yml)
+
+## Description
+
+The Cratis Application model represents an opinionated approach to building consistent applications based on the concepts behind CQRS.
+It offers extensions for different frameworks and is built on top of ASP.NET Core. One of the traits of Arc has is the
+bridging between the backend and the frontend. Arc provides a tool, called **ProxyGenerator** that generates TypeScript
+code for recognized artifacts matching the criteria of what is considered a **commmand** or a **query**.
+
+## Contributing
+
+If you want to jump into building this repository and possibly contributing, please refer to [contributing](./Documentation/contributing/index.md).
+
+### Prerequisites
+
+The following are prerequisites to work with this repository.
+
+* [.NET 8+](https://dotnet.microsoft.com/en-us/).
+* [Node 16+](https://nodejs.org/en)
+* [Yarn](https://yarnpkg.com)
+
+### Central Package Management
+
+This repository leverages [Central Package Management](https://learn.microsoft.com/en-us/nuget/consume-packages/Central-Package-Management), which
+means that all package versions are managed from a file at the root level called [Directory.Packages.props](./Directory.Packages.props).
+
+In addition there are also [Directory.Build.props](https://learn.microsoft.com/en-us/visualstudio/msbuild/customize-by-directory?view=vs-2022#directorybuildprops-and-directorybuildtargets) files for
+setting up common settings that are applied cross cuttingly.
+
+### Root package.json
+
+The `package.json` found at the root level defines all the workspaces. It is assumed
+
+All developer dependencies are defined in the top level `package.json`. The reason for this is to be able to provide global scripts
+for every package to use for easier maintenance.
+
+The `package.json` found at the top level contains scripts that can then be used in a child project for this to work properly.
+
+In a package, all you need to do is to define the scripts to use the global scripts in the `package.json´ of that project:
+
+```json
+{
+    "scripts": {
+        "prepublish": "yarn g:build",
+        "clean": "yarn g:clean",
+        "build": "yarn g:build",
+        "lint": "yarn g:lint",
+        "lint:ci": "yarn g:lint:ci",
+        "test": "yarn g:test",
+        "ci": "yarn g:ci",
+        "up": "yarn g:up"
+    }
+}
+```

package/WellKnownBindings.ts

@@ -0,0 +1,11 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/**
+ * Well-known IoC binding constants.
+ */
+export const WellKnownBindings = {
+    queryParams: 'queryParams',
+    params: 'params',
+    props: 'props'
+};

package/browser/ILocalStorage.ts

@@ -0,0 +1,11 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export abstract class ILocalStorage implements Storage {
+    abstract length: number;
+    abstract clear(): void;
+    abstract getItem(key: string): string | null;
+    abstract key(index: number): string | null;
+    abstract removeItem(key: string): void;
+    abstract setItem(key: string, value: string): void;
+}

package/browser/INavigation.ts

@@ -0,0 +1,9 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export type UrlChangedCallback = (url: string, previousUrl: string) => void;
+
+export abstract class INavigation {
+    abstract onUrlChanged(callback: UrlChangedCallback): void;
+}
+

package/browser/Navigation.ts

@@ -0,0 +1,29 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { INavigation, UrlChangedCallback } from './INavigation';
+
+export class Navigation implements INavigation {
+    private readonly _callbacks: UrlChangedCallback[] = [];
+
+    constructor() {
+        const previousUrl = location.href;
+        const observer = new MutationObserver(() => {
+            if (location.href !== previousUrl) {
+                for( const callback of this._callbacks ) {
+                    callback(location.href, previousUrl);
+                }
+            }
+        });
+        observer.observe(document.body,
+            {
+                childList: true,
+                subtree: true
+            }
+        );
+    }
+
+    onUrlChanged(callback: UrlChangedCallback): void {
+        this._callbacks.push(callback);
+    }
+}

package/browser/index.ts

@@ -0,0 +1,6 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export * from './INavigation';
+export * from './Navigation';
+export * from './ILocalStorage';

package/dialogs/BusyIndicator.ts

@@ -0,0 +1,24 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { CloseDialog, DialogResult } from '@cratis/arc.react/dialogs';
+
+/**
+ * Represents a busy indicator dialog.
+ */
+export class BusyIndicator {
+
+    /**
+     * Initializes a new instance of {@link BusyIndicator}.
+     * @param {CloseDialog<void>} _closeDialog The dialog resolver to use for closing the dialog.
+     */
+    constructor(private readonly _closeDialog: CloseDialog<void>) {
+    }
+
+    /**
+     * Close the busy indicator dialog.
+     */
+    close() {
+        this._closeDialog(DialogResult.None);
+    }
+}

package/dialogs/DialogMediator.tsx

@@ -0,0 +1,51 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import React from 'react';
+import { IDialogMediatorHandler } from './IDialogMediatorHandler';
+
+/**
+ * Context for the dialog mediator.
+ */
+export const DialogMediatorContext = React.createContext<IDialogMediatorHandler>(undefined!);
+
+/**
+ * Props for the dialog mediator.
+ */
+export interface DialogMediatorProps {
+    /**
+     * Children to provide the dialog mediator to.
+     */
+    children?: JSX.Element | JSX.Element[];
+
+    /**
+     * The dialog mediator context.
+     */
+    handler: IDialogMediatorHandler;
+
+    /**
+     * Parent handler, if any.
+     */
+    parentHandler?: IDialogMediatorHandler;
+}
+
+/**
+ * Use the dialog mediator.
+ * @returns The dialog mediator.
+ */
+export const useDialogMediator = () => {
+    return React.useContext(DialogMediatorContext);
+};
+
+/**
+ * Provide the dialog mediator to the children.
+ * @param {DialogMediatorProps} props Props for the dialog mediator.
+ * @returns Provider for the dialog mediator.
+ */
+export const DialogMediator = (props: DialogMediatorProps) => {
+    return (
+        <DialogMediatorContext.Provider value={props.handler}>
+            {props.children}
+        </DialogMediatorContext.Provider>
+    );
+};

package/dialogs/DialogMediatorHandler.ts

@@ -0,0 +1,67 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Constructor } from '@cratis/fundamentals';
+import { CloseDialog, DialogResponse } from '@cratis/arc.react/dialogs';
+import { IDialogMediatorHandler } from './IDialogMediatorHandler';
+import { DialogRegistration, DialogRequest } from './DialogRegistration';
+
+/**
+ * Represents an implementation of {@link IDialogMediatorHandler}
+ */
+export class DialogMediatorHandler extends IDialogMediatorHandler {
+    private _registrations: WeakMap<Constructor, DialogRegistration<object, object>> = new WeakMap();
+
+    /**
+     * Initializes a new instance of {@link DialogMediatorHandler}
+     * @param {IDialogMediatorHandler} _parent Optional parent handler.
+     */
+    constructor(readonly _parent: IDialogMediatorHandler | null = null) {
+        super();
+    }
+
+    /** @inheritdoc */
+    subscribe<TRequest extends object, TResponse>(requestType: Constructor<TRequest>, requester: DialogRequest<TRequest, TResponse>, closeDialog: CloseDialog<TResponse>): void {
+        this._registrations.set(
+            requestType,
+            new DialogRegistration<TRequest, TResponse>(requester, closeDialog) as unknown as DialogRegistration<object, object>);
+    }
+
+    /** @inheritdoc */
+    hasSubscriber<TRequest extends object>(requestType: Constructor<TRequest>): boolean {
+        return this._registrations.has(requestType);
+    }
+
+    /** @inheritdoc */
+    show<TRequest extends object, TResponse>(request: TRequest): Promise<DialogResponse<TResponse>> {
+        if (!this.hasSubscriber(request.constructor as Constructor)) {
+            if (this._parent) {
+                return this._parent.show(request);
+            }
+
+            return Promise.reject('No registration found for request');
+        }
+
+        const promise = new Promise<DialogResponse<TResponse>>((resolve) => {
+            const registration = this._registrations.get(request.constructor as Constructor)!;
+            registration.requester(request, (result, response) => {
+                resolve([result, response as TResponse]);
+            });
+        });
+
+        return promise;
+    }
+
+    /** @inheritdoc */
+    getRegistration<TRequest extends object, TResponse>(requestType: Constructor<TRequest>): DialogRegistration<TRequest, TResponse> {
+        if (!this.hasSubscriber(requestType)) {
+            if (this._parent) {
+                return this._parent.getRegistration(requestType);
+            }
+
+            throw new Error('No registration found for request');
+        }
+
+        return this._registrations.get(requestType)! as unknown as DialogRegistration<TRequest, TResponse>;
+    }
+}

package/dialogs/DialogRegistration.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { CloseDialog } from '@cratis/arc.react/dialogs';
+
+/**
+ * Represents the delegate for a dialog request.
+ */
+export type DialogRequest<TRequest extends object, TResponse> = (request: TRequest, closeDialog: CloseDialog<TResponse>) => void;
+
+/**
+ * Represents the registration of a dialog.
+ */
+export class DialogRegistration<TRequest extends object, TResponse> {
+
+    /**
+     * Initializes a new instance of {@link DialogRegistration}.
+     * @param requester The requester for the dialog.
+     * @param resolver The resolver for the dialog.
+     */
+    constructor(
+        readonly requester: DialogRequest<TRequest, TResponse>,
+        readonly resolver: CloseDialog<TResponse>) {
+    }   
+}

package/dialogs/Dialogs.ts

@@ -0,0 +1,58 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { DialogResponse, DialogResult, IDialogComponents, ConfirmationDialogRequest, BusyIndicatorDialogRequest, CloseDialog } from '@cratis/arc.react/dialogs';
+import { DialogButtons } from '@cratis/arc.react/dialogs/DialogButtons';
+import { IDialogs } from './IDialogs';
+import { BusyIndicator } from './BusyIndicator';
+import { IDialogMediatorHandler } from './IDialogMediatorHandler';
+
+/**
+ * Represents an implementation of {@link IDialogs}.
+ */
+export class Dialogs extends IDialogs {
+
+    /**
+     * Initializes a new instance of the {@link Dialogs} class.
+     */
+    constructor(
+        private readonly _dialogMediatorHandler: IDialogMediatorHandler,
+        dialogComponents: IDialogComponents) {
+        super();
+
+        /* eslint-disable @typescript-eslint/no-empty-function */
+        _dialogMediatorHandler.subscribe(ConfirmationDialogRequest, async (request, resolver) => {
+            const [result] = await dialogComponents.showConfirmation(request as ConfirmationDialogRequest);
+            resolver(result);
+        }, () => { });
+        /* eslint-enable @typescript-eslint/no-empty-function */
+
+        let busyIndicatorResolver: CloseDialog<void> | undefined = undefined;
+
+        _dialogMediatorHandler.subscribe(BusyIndicatorDialogRequest, (request, resolver) => {
+            busyIndicatorResolver = resolver;
+            return dialogComponents.showBusyIndicator(request as BusyIndicatorDialogRequest);
+        }, () => { 
+            busyIndicatorResolver?.(DialogResult.Cancelled, undefined);
+        });
+    }
+
+    /** @inheritdoc */
+    show<TRequest extends object, TResponse = object>(request: TRequest): Promise<DialogResponse<TResponse>> {
+        return this._dialogMediatorHandler.show<TRequest, TResponse>(request);
+    }
+
+    /** @inheritdoc */
+    async showConfirmation(title: string, message: string, buttons: DialogButtons): Promise<DialogResult> {
+        const [result] = await this.show<ConfirmationDialogRequest>(new ConfirmationDialogRequest(title, message, buttons));
+        return result;
+    }
+
+    /** @inheritdoc */
+    showBusyIndicator(title: string, message: string): BusyIndicator {
+        this.show<BusyIndicatorDialogRequest, void>(new BusyIndicatorDialogRequest(title, message));
+        const registration = this._dialogMediatorHandler.getRegistration<BusyIndicatorDialogRequest, void>(BusyIndicatorDialogRequest);
+        const busyIndicator = new BusyIndicator(registration.resolver);
+        return busyIndicator;
+    }
+}

package/dialogs/IDialogMediatorHandler.ts

@@ -0,0 +1,40 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Constructor } from '@cratis/fundamentals';
+import { CloseDialog, DialogResponse } from '@cratis/arc.react/dialogs';
+import { DialogRegistration, DialogRequest } from './DialogRegistration';
+
+/**
+ * Defines a system that can handle dialog requests and responses.
+ */
+export abstract class IDialogMediatorHandler {
+
+    /**
+     * Subscribes to a request type.
+     * @param {Constructor} requestType Type of request.
+     * @param {DialogRequest} requester The delegate that will be called when a request is made.
+     * @param {CloseDialog} closeDialog The delegate that will be called when dialog is typically closed and response is resolved.
+     */
+    abstract subscribe<TRequest extends object, TResponse>(requestType: Constructor<TRequest>, requester: DialogRequest<TRequest, TResponse>, closeDialog: CloseDialog<TResponse>): void;
+
+    /**
+     * Check if there is a subscriber for a given request type.
+     * @param {Constructor} requestType Type of request.
+     * @returns {boolean} True if there is a subscriber, false otherwise.
+     */
+    abstract hasSubscriber<TRequest extends object>(requestType: Constructor<TRequest>): boolean;
+
+    /**
+     * Show a dialog based on a request.
+     * @param {*} request An instance of the dialog request.
+     */
+    abstract show<TRequest extends object, TResponse>(request: TRequest): Promise<DialogResponse<TResponse>>;
+
+    /**
+     * Get the registration for a given request type.
+     * @param {Constructor} requestType Type of request.
+     * @returns {DialogRegistration} The registration for the request type.
+     */
+    abstract getRegistration<TRequest extends object, TResponse>(requestType: Constructor<TRequest>): DialogRegistration<TRequest, TResponse>;
+}

package/dialogs/IDialogs.ts

@@ -0,0 +1,37 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { DialogResponse, DialogResult } from '@cratis/arc.react/dialogs';
+import { DialogButtons } from '@cratis/arc.react/dialogs/DialogButtons';
+import { BusyIndicator } from './BusyIndicator';
+
+/**
+ * Defines a service for working with dialogs from a view model.
+ */
+export abstract class IDialogs {
+    /**
+     * Show a dialog in the context of the current view and view model. This requires the view to host the dialog.
+     * @param {*} input The input to pass to the dialog.
+     * @returns {Promise<*>} The output from the dialog.
+     */
+    abstract show<TRequest extends object, TResponse = object>(input: TRequest): Promise<DialogResponse<TResponse>>;
+
+    /**
+     * Show a standard confirmation dialog.
+     * @param {String} title Title of the dialog.
+     * @param {String} message Message to show inside the dialog.
+     * @param {DialogButtons} buttons Buttons to have on the dialog
+     * @returns {Promise<DialogResult>} The result of the dialog.
+     */
+    abstract showConfirmation(title: string, message: string, buttons: DialogButtons): Promise<DialogResult>;
+
+    /**
+     * Show a standard busy indicator dialog.
+     * @param {String} title Title of the dialog.
+     * @param {String} message Message to show inside the dialog.
+     * @returns {BusyIndicator} The busy indicator instance.
+     */
+    abstract showBusyIndicator(title: string, message: string): BusyIndicator;
+}
+
+

package/dialogs/index.ts

@@ -0,0 +1,12 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export * from './BusyIndicator';
+export * from './DialogMediator';
+export * from './DialogMediatorHandler';
+export * from './DialogRegistration';
+export * from './Dialogs';
+export * from './IDialogMediatorHandler';
+export * from './IDialogs';
+export * from './Dialogs';
+export * from './useDialog';

package/dialogs/useDialog.tsx

@@ -0,0 +1,34 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { useEffect, ComponentType, FC, useCallback } from 'react';
+import { Constructor } from '@cratis/fundamentals';
+import { DialogResult, ShowDialog, useDialog as useDialogBase } from '@cratis/arc.react/dialogs';
+import { useDialogMediator } from './DialogMediator';
+
+/**
+ * Use a dialog request for showing a dialog, similar to useDialog.
+ * @param requestType Type of request to use that represents a request that will be made by your view model.
+ * @param DialogComponent The dialog component to render.
+ * @returns A tuple with a component to use for rendering the dialog.
+ */
+export function useDialog<TProps extends object = object, TResponse = object>(
+    requestType: Constructor<TProps>,
+    DialogComponent: ComponentType<TProps>
+): [FC<TProps>, ShowDialog<TProps, TResponse>] {
+    const mediator = useDialogMediator();
+    const [DialogWrapper, showDialog, actualDialogContext] = useDialogBase<TResponse, TProps>(DialogComponent);
+
+    const closeDialog = useCallback((result: DialogResult, value?: TResponse) => {
+        actualDialogContext.closeDialog(result, value as TResponse);
+    }, []);
+
+    useEffect(() => {
+        mediator.subscribe(requestType, async (request, resolver) => {
+            const [result, response] = await showDialog(request as unknown as TProps);
+            resolver(result, response);
+        }, closeDialog);
+    }, []);
+
+    return [DialogWrapper, showDialog];
+}

package/dist/cjs/Bindings.d.ts

@@ -0,0 +1,4 @@
+export declare class Bindings {
+    static initialize(): void;
+}
+//# sourceMappingURL=Bindings.d.ts.map

package/dist/cjs/Bindings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bindings.d.ts","sourceRoot":"","sources":["../../Bindings.ts"],"names":[],"mappings":"AASA,qBAAa,QAAQ;IACjB,MAAM,CAAC,UAAU;CAMpB"}

package/dist/cjs/Bindings.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var tsyringe = require('tsyringe');
+var IMessenger = require('./messaging/IMessenger.js');
+var Messenger = require('./messaging/Messenger.js');
+var INavigation = require('./browser/INavigation.js');
+var Navigation = require('./browser/Navigation.js');
+var ILocalStorage = require('./browser/ILocalStorage.js');
+var identity = require('@cratis/arc/identity');
+
+class Bindings {
+    static initialize() {
+        tsyringe.container.registerSingleton(IMessenger.IMessenger, Messenger.Messenger);
+        tsyringe.container.registerSingleton(INavigation.INavigation, Navigation.Navigation);
+        tsyringe.container.registerSingleton(identity.IIdentityProvider, identity.IdentityProvider);
+        tsyringe.container.registerInstance(ILocalStorage.ILocalStorage, localStorage);
+    }
+}
+
+exports.Bindings = Bindings;
+//# sourceMappingURL=Bindings.js.map