@genesislcap/foundation-login 9.0.1-alpha-b5c5eb7.0

package/dist/dts/main/config.d.ts

@@ -0,0 +1,261 @@
+import { ElementStyles } from '@microsoft/fast-element';
+import { Container } from '@microsoft/fast-foundation';
+/**
+ * @public
+ */
+export declare const defaultOrganisation: string;
+/**
+ * @public
+ */
+export declare const defaultUser: string;
+/**
+ * @public
+ */
+export declare const defaultPassword: string;
+/**
+ * @public
+ */
+export declare const defaultApiHost: string;
+/**
+ * @public
+ */
+export declare const defaultSocketExt: string;
+/**
+ * @public
+ */
+export declare const hostEnv: string;
+/**
+ * @public
+ */
+export declare const hostUrl: string;
+/**
+ * @public
+ */
+export declare const Routes: {
+    readonly login: "login";
+    readonly 'request-account': "request-account";
+    readonly 'reset-password': "reset-password";
+    readonly 'forgot-password': "forgot-password";
+    readonly verify: "verify";
+    readonly protected: "protected";
+    readonly 'not-found': "not-found";
+};
+/**
+ * @public
+ */
+export type Routes = (typeof Routes)[keyof typeof Routes];
+/**
+ * A utility to check if a pathname is a route of this micro frontend.
+ *
+ * @param pathname - A pathname string to check, typically location.pathname, which is used when a value is omitted.
+ *
+ * @public
+ * @privateRemarks
+ * I've just put this util in for now given there's some app level direction code in place which needs review.
+ */
+export declare function isMFRoute(pathname?: string): boolean;
+/**
+ * @public
+ * Could be expanded to allow field ViewTemplates.
+ */
+export type FieldConfig = {
+    label: string;
+    /**
+     * @privateRemarks
+     * Added for now to apply defaults, but I'm not convinced we should do this. Could be made reactive after upgrade.
+     */
+    value?: any;
+};
+/**
+ * @public
+ * @privateRemarks
+ * Using null to exclude the organisation field rather than boolean, as it affords cleaner value lookups in the templates.
+ */
+export type FieldConfigMap = {
+    organisation: FieldConfig | null;
+    username: FieldConfig;
+    email: FieldConfig;
+    password: FieldConfig;
+};
+/**
+ * @public
+ */
+export type SSOConfig = {
+    /**
+     * Optionally toggle the SSO journey on/off by default.
+     */
+    toggled?: boolean;
+    /**
+     * The identity providers path under the current host.
+     *
+     * @example
+     * ```ts
+     * identityProvidersPath: 'sso/list'
+     * ```
+     */
+    identityProvidersPath: string;
+};
+/**
+ * LoginConfig DI interface.
+ *
+ * @public
+ */
+export interface LoginConfig {
+    /**
+     * Connect automatically or require user to click a connect button.
+     */
+    autoConnect: boolean;
+    /**
+     * Login automatically or require user to click a login button after a connection is established.
+     *
+     * @remarks
+     * Needs to manually be enabled in the NavigationContributor (see [2] in the example in the {@link Login} class).
+     */
+    autoAuth: boolean;
+    /**
+     * Logo styles.
+     *
+     * @remarks
+     * Providing `null` will hide the logo. Use content: url(...); to set source.
+     *
+     * @example Setting a custom logo
+     * ```ts
+     * logo: css`
+     *     content: url(${customLogoImport});
+     * `,
+     * ```
+     */
+    logo: ElementStyles | null;
+    /**
+     * Background styles.
+     *
+     * @remarks
+     * See {@link https://developer.mozilla.org/en-US/docs/Web/CSS/background} for more information.
+     *
+     * @example Setting a custom background image
+     * ```ts
+     * background: css`
+     *     :host {
+     *         background-image: url(${customBGImport});
+     *     }
+     * `,
+     * ```
+     */
+    background: ElementStyles;
+    /**
+     * Omit any of the internal routes except 'login' and 'not-found'.
+     *
+     * @remarks
+     * Routes specified here will not be configured nor will any internal cross-links to them be displayed.
+     *
+     * @example
+     * ```ts
+     * omitRoutes: ['request-account'],
+     * ```
+     */
+    omitRoutes: Exclude<Routes, 'login' | 'not-found'>[];
+    /**
+     * Map of configuration for each of the primary form fields.
+     *
+     * @remarks
+     * Use to drive inclusion / exclusion, tailor labels etc.
+     */
+    fields: FieldConfigMap;
+    /**
+     * Show or hide the connection status indicator.
+     */
+    showConnectionIndicator: boolean;
+    /**
+     * The default URL to route the user to after a successful login.
+     *
+     * @remarks
+     * Session.returnUrl set via Session.captureReturnUrl() trumps this value.
+     */
+    defaultRedirectUrl: string;
+    /**
+     * Omit certain return urls which the session service may have captured.
+     *
+     * @example
+     * ```ts
+     * omitRedirectUrls: ['/not-found'],
+     * ```
+     */
+    omitRedirectUrls: string[];
+    /**
+     * SSO configuration.
+     *
+     * @remarks
+     * Providing `null` excludes the SSO journey option completely.
+     */
+    sso: SSOConfig | null;
+    /**
+     * Display arbitrary version information.
+     *
+     * @remarks
+     * Applications may choose to set this to display their Application release version on the login form.
+     *
+     * @example
+     * ```ts
+     * versionInformation: 'Version 3.0.0',
+     * ```
+     */
+    versionInformation?: string;
+}
+/**
+ * Default LoginConfig DI implementation.
+ * @public
+ */
+export declare const defaultLoginConfig: LoginConfig;
+/**
+ * LoginConfig DI key.
+ *
+ * @internal
+ * @privateRemarks
+ * Marked as internal to stop api-extractor becoming confused cross-linking tokens with the same name.
+ */
+export declare const LoginConfig: import("@microsoft/fast-foundation").InterfaceSymbol<LoginConfig>;
+/**
+ * Configure the login micro frontend settings.
+ *
+ * @remarks
+ * This is primarily for general settings, rather than re-defining the element, static templating / style changes.
+ *
+ * @param container - DI container.
+ * @param config - A partial LoginConfig.
+ *
+ * @example Configuring login on lazy load
+ * ```ts
+ * name: 'login',
+ * path: 'login',
+ * title: 'Login',
+ * element: async () => {
+ *   const { configure, define, defaultLoginConfig } = await import('@genesislcap/foundation-login');
+ *   configure(this.container, {
+ *     autoConnect: true,
+ *     omitRoutes: ['request-account'],
+ *     fields: {
+ *       ...defaultLoginConfig.fields,
+ *       organisation: {
+ *         label: 'CompID',
+ *       },
+ *     },
+ *     defaultRedirectUrl: 'dashboard',
+ *     logo: loginLogo,
+ *     background: loginBG,
+ *   });
+ *   // You can import and return `Login` directly here or re-define it completely via `define`.
+ *   return define({
+ *     name: `nexus-login`,
+ *   });
+ * },
+ * layout: loginLayout,
+ * settings: { public: true },
+ * childRouters: true,
+ * ```
+ *
+ * @public
+ * @privateRemarks
+ * We can tailor the spreading logic after we put it to use. Keeping it simple for now.
+ */
+export declare function configure(container: Container, config: Partial<LoginConfig>): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/dts/main/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/main/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAoB,MAAM,4BAA4B,CAAC;AASzE;;GAEG;AACH,eAAO,MAAM,mBAAmB,QAAuB,CAAC;AAIxD;;GAEG;AACH,eAAO,MAAM,WAAW,QAAe,CAAC;AAIxC;;GAEG;AACH,eAAO,MAAM,eAAe,QAAmB,CAAC;AAIhD;;GAEG;AACH,eAAO,MAAM,cAAc,QAAW,CAAC;AAIvC;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAAa,CAAC;AAE3C;;GAEG;AACH,eAAO,MAAM,OAAO,QAAgB,CAAC;AAIrC;;GAEG;AACH,eAAO,MAAM,OAAO,QAAwD,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;;;CAQT,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,OAAO,MAAM,CAAC,CAAC;AAE1D;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,QAAQ,GAAE,MAA0B,GAAG,OAAO,CAKvE;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,KAAK,CAAC,EAAE,GAAG,CAAC;CACb,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,YAAY,EAAE,WAAW,GAAG,IAAI,CAAC;IACjC,QAAQ,EAAE,WAAW,CAAC;IACtB,KAAK,EAAE,WAAW,CAAC;IACnB,QAAQ,EAAE,WAAW,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;OAOG;IACH,qBAAqB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;;;OAYG;IACH,IAAI,EAAE,aAAa,GAAG,IAAI,CAAC;IAC3B;;;;;;;;;;;;;;OAcG;IACH,UAAU,EAAE,aAAa,CAAC;IAC1B;;;;;;;;;;OAUG;IACH,UAAU,EAAE,OAAO,CAAC,MAAM,EAAE,OAAO,GAAG,WAAW,CAAC,EAAE,CAAC;IACrD;;;;;OAKG;IACH,MAAM,EAAE,cAAc,CAAC;IACvB;;OAEG;IACH,uBAAuB,EAAE,OAAO,CAAC;IACjC;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;;;;OAOG;IACH,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B;;;;;OAKG;IACH,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IACtB;;;;;;;;;;OAUG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAgChC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,mEAAoC,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC,QAO3E"}

package/dist/dts/main/define.d.ts

@@ -0,0 +1,29 @@
+import { Login } from './main';
+/**
+ * Re-define the login micro frontend.
+ *
+ * @example
+ * ```ts
+ * import { define, styles, template, defaultTemplateOptions } from '@genesislcap/foundation-login';
+ * const customTemplateOptions = {
+ *   ...defaultTemplateOptions,
+ *   ...customOptions,
+ * }
+ * export const AppLogin = define({
+ *   name: `nexus-login`,
+ *   template: template(customTemplateOptions),
+ *   styles: css`
+ *     ${styles(customTemplateOptions)}
+ *     some-element {
+ *       background-color: #ff00b4;
+ *     }
+ *  `,
+ * });
+ * ```
+ *
+ * @beta
+ * @privateRemarks
+ * TODO: Use LoginHosted instead of Login when elements manifest stuff lands, which will drive tagFor etc.
+ */
+export declare const define: import("@genesislcap/foundation-ui").DefineFunction<typeof Login>;
+//# sourceMappingURL=define.d.ts.map

package/dist/dts/main/define.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../../src/main/define.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAG/B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,MAAM,mEAAmC,CAAC"}

package/dist/dts/main/index.d.ts

@@ -0,0 +1,7 @@
+export * from './config';
+export * from './define';
+export * from './main.definition';
+export * from './main.template';
+export * from './main.styles';
+export * from './main';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/main/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/main/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,QAAQ,CAAC"}

package/dist/dts/main/main.d.ts

@@ -0,0 +1,179 @@
+import { Session } from '@genesislcap/foundation-comms';
+import { FASTElement } from '@microsoft/fast-element';
+import { Container } from '@microsoft/fast-foundation';
+import { MainRouterConfig } from '../routes';
+/**
+ * Defines the login class which handles account authentication from the front-end
+ *
+ * @remarks
+ *
+ * Add the Login class as a router element, and it will handle the account authentication for you.
+ * Requires use of `@genesislcap/foundation-comms` for the {@link @genesislcap/foundation-comms#Auth | Auth} and
+ * {@link @genesislcap/foundation#Session | Session} classes.
+ *
+ * There are a lot of configuration options available, and different authentication types (such as login via SSO). Use
+ * the modules exported `configure` and `define` functions for more power.
+ *
+ * @example
+ * The following is an example of using it in your app, setting it up in the router configuration. This isn't a complete
+ * routes confutation, but it contains all required configuration in regard to adding Login functionality.
+ * ```ts
+ * // Import required dependencies from the foundation-login package
+ * import { Login } from '@genesislcap/foundation-login';
+ * // Import required dependencies from the foundation-comms package
+ * // You could also import analytics events and set them up in the NavigationContributor
+ * import { Auth, Session } from '@genesislcap/foundation-comms';
+ *
+ * type RouterSettings = {
+ *   public?: boolean;
+ *   autoAuth?: boolean;
+ * }
+ *
+ * // Define your router config
+ * export class MainRouterConfig extends RouterConfiguration<RouterSettings> {
+ *   // Ensure you inject in required dependencies
+ *   constructor(
+ *     @Auth private auth: Auth,
+ *     @Session private session: Session
+ *   ) {
+ *     super();
+ *   }
+ *
+ *   // Add Login as a route
+ *   public configure() {
+ *     ...
+ *     this.routes.map(
+ *       { path: '', redirect: 'login' },
+ *       {
+ *         path: 'login',
+ *         element: Login,
+ *         title: 'Login',
+ *         name: 'login',
+ *         layout: loginLayout,
+ *         settings: { public: true },
+ *         childRouters: true,
+ *       },
+ *       ... // Other routes config here
+ *     );
+ *
+ *     const session = this.session;
+ *     const auth = this.auth;
+ *
+ *     // Example of a FallbackRouteDefinition
+ *     this.routes.fallback(() =>
+ *       auth.isLoggedIn ? { redirect: 'not-found' } : { redirect: 'login' }
+ *     );
+ *
+ *      // Example of a NavigationContributor
+ *     this.contributors.push({
+ *       navigate: async (phase) => {
+ *         const settings = phase.route.settings;
+ *
+ *         // Could add in processes such as analytics here
+ *
+ *         // If public route don't block
+ *         if (settings && settings.public) {
+ *           return;
+ *         }
+ *
+ *         // If logged in don't block
+ *         if (auth.isLoggedIn) {
+ *           return;
+ *         }
+ *
+ *         // If autoAuth and session is valid try to connect+auto-login
+ *         if (settings && settings.autoAuth && (await auth.reAuthFromSession())) {
+ *           return;
+ *         }
+ *
+ *         // Otherwise route them to login
+ *         phase.cancel(() => {
+ *           session.captureReturnUrl();
+ *           Route.name.replace(phase.router, 'login');
+ *         });
+ *       },
+ *     });
+ *   }
+ *
+ *   ... // Other configuration/methods
+ *
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare class Login extends FASTElement {
+    /**
+     * Configuration for the routes and their associated settings.
+     * The client would override this in their app with their own settings to set
+     * their routes up as desired
+     * @internal
+     */
+    config: MainRouterConfig;
+    /**
+     * The DI container used to register required components in {@link Login.registerDIDependencies}
+     * @internal
+     */
+    container: Container;
+    /**
+     * Session controller used to manage the user's session
+     * @internal
+     */
+    session: Session;
+    /**
+     * Marked true when remote components are loaded, currently unused.
+     * @internal
+     */
+    ready: boolean;
+    /**
+     * DS provider / root level template.
+     * @internal
+     */
+    provider: FASTElement;
+    /**
+     * @internal
+     */
+    connectedCallback(): Promise<void>;
+    /**
+     * Used to forward the user onto a logged-in session during an SSO journey
+     *
+     * @remarks
+     *
+     * Called when loading the login page via the connectedCallback() method.
+     * During normal flows there will be no SSO tokens set and hence this function
+     * will quit execution.
+     * During an SSO journey the SSO provider will set the SSO token as a URLSearchParams
+     * parameter and redirect back to us. In this case we will take this and forward the
+     * user on, with their logged in session.
+     *
+     * There are two paths the user can take here - if they are in a popup
+     * (window.opener exists) then we need to set the session and get the parent window
+     * (the one which the user wants their session on) to refresh, and close the popup.
+     *
+     * Or if they are not in a popup then we simply set the ssoToken in the session.
+     * When this component is loaded with the ssoToken then it will redirect the
+     * user to their app (the `defaultRedirectUrl`).
+     *
+     * @internal
+     */
+    checkForSSOToken(): void;
+    /**
+     * Called from the connectedCallback
+     * @internal
+     */
+    registerCommonComponents(): Promise<void>;
+    /**
+     * @internal
+     */
+    protected registerDIDependencies(): void;
+}
+/**
+ * @beta
+ * @privateRemarks
+ * A hosted version of the MF that doesn't set up a design system or components. This is what apps would use to truly
+ * customise the MF for their needs via define.ts.
+ */
+export declare class LoginHosted extends Login {
+    registerCommonComponents(): Promise<void>;
+}
+//# sourceMappingURL=main.d.ts.map

package/dist/dts/main/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../src/main/main.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuC,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAC7F,OAAO,EAAiB,WAAW,EAAc,MAAM,yBAAyB,CAAC;AACjF,OAAO,EAAE,SAAS,EAAwB,MAAM,4BAA4B,CAAC;AAG7E,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAG7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AACH,qBACa,KAAM,SAAQ,WAAW;IACpC;;;;;OAKG;IACuB,MAAM,EAAG,gBAAgB,CAAC;IAEpD;;;OAGG;IACQ,SAAS,EAAG,SAAS,CAAC;IAEjC;;;OAGG;IACM,OAAO,EAAG,OAAO,CAAC;IAE3B;;;OAGG;IACS,KAAK,EAAE,OAAO,CAAS;IAEnC;;;OAGG;IACS,QAAQ,EAAG,WAAW,CAAC;IAEnC;;OAEG;IACG,iBAAiB;IAOvB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,gBAAgB;IAchB;;;OAGG;IACG,wBAAwB;IAa9B;;OAEG;IACH,SAAS,CAAC,sBAAsB;CAgBjC;AAED;;;;;GAKG;AACH,qBAIa,WAAY,SAAQ,KAAK;IAC9B,wBAAwB;CAG/B"}

package/dist/dts/main/main.definition.d.ts

@@ -0,0 +1,48 @@
+import { TemplateElementDependency } from '@genesislcap/foundation-ui';
+import { PartialFASTElementDefinition, SyntheticViewTemplate } from '@microsoft/fast-element';
+/**
+ * @beta
+ * @privateRemarks
+ * The CLI can be used to monitor what is in use and needs a mapping.
+ */
+export type TemplateComponents = {
+    anchor: TemplateElementDependency;
+    button: TemplateElementDependency;
+    card: TemplateElementDependency;
+    checkbox: TemplateElementDependency;
+    listboxOption: TemplateElementDependency;
+    provider: TemplateElementDependency;
+    router: TemplateElementDependency;
+    select: TemplateElementDependency;
+    textField: TemplateElementDependency;
+};
+/**
+ * @beta
+ */
+export type TemplateOptions = TemplateComponents & {
+    somePartial?: string | SyntheticViewTemplate;
+};
+/**
+ * The default template options this MF has been created with.
+ * @beta
+ * @privateRemarks
+ * This will likely evolve into the shell style PWA + FDC3 manifest setup, but that needs more work to evolve into MVP.
+ * Hosts should be able to figure out everything they will need to do to fully customise a MF. Currently, they
+ * import these `defaultTemplateOptions` and the host dev overrides. Each TemplateComponents key must be a mandatory
+ * override, given in hosted mode the MFs won't be registering fallbacks as this would be wasteful, bloat etc.
+ * I've added the components list to the package.json > config block for now, but I'm not using it here.
+ */
+export declare const defaultTemplateOptions: TemplateOptions;
+/**
+ * @beta
+ * @remarks
+ * This is the main definition of this micro frontend which is exposed for user reconfiguration.
+ */
+export declare const definition: PartialFASTElementDefinition;
+/**
+ * @internal
+ * @privateRemarks
+ * This is used during development of this micro frontend.
+ */
+export declare const standaloneDefinition: PartialFASTElementDefinition;
+//# sourceMappingURL=main.definition.d.ts.map

package/dist/dts/main/main.definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.definition.d.ts","sourceRoot":"","sources":["../../../src/main/main.definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,4BAA4B,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAI9F;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,yBAAyB,CAAC;IAClC,MAAM,EAAE,yBAAyB,CAAC;IAClC,IAAI,EAAE,yBAAyB,CAAC;IAChC,QAAQ,EAAE,yBAAyB,CAAC;IACpC,aAAa,EAAE,yBAAyB,CAAC;IACzC,QAAQ,EAAE,yBAAyB,CAAC;IACpC,MAAM,EAAE,yBAAyB,CAAC;IAClC,MAAM,EAAE,yBAAyB,CAAC;IAClC,SAAS,EAAE,yBAAyB,CAAC;CACtC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,kBAAkB,GAAG;IACjD,WAAW,CAAC,EAAE,MAAM,GAAG,qBAAqB,CAAC;CAC9C,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAUpC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,EAAE,4BAIxB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,4BAUlC,CAAC"}

package/dist/dts/main/main.styles.d.ts

@@ -0,0 +1,13 @@
+import type { TemplateOptions } from './main.definition';
+/**
+ * @public
+ * @privateRemarks
+ * Options cam be used to target unknown component tags in the css, such as:
+ * const buttonTag = tagFor(options.button);
+ * ...
+ * ${buttonTag} {
+ *   width: 200px;
+ * }
+ */
+export declare const styles: (options: TemplateOptions) => import("@microsoft/fast-element").ElementStyles;
+//# sourceMappingURL=main.styles.d.ts.map

package/dist/dts/main/main.styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.styles.d.ts","sourceRoot":"","sources":["../../../src/main/main.styles.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGzD;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,YAAa,eAAe,oDAwB9C,CAAC"}

package/dist/dts/main/main.template.d.ts

@@ -0,0 +1,7 @@
+import type { TemplateOptions } from './main.definition';
+import type { Login } from './main';
+/**
+ * @public
+ */
+export declare const template: (options: TemplateOptions) => import("@microsoft/fast-element").ViewTemplate<Login, any>;
+//# sourceMappingURL=main.template.d.ts.map

package/dist/dts/main/main.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.template.d.ts","sourceRoot":"","sources":["../../../src/main/main.template.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAEpC;;GAEG;AACH,eAAO,MAAM,QAAQ,YAAa,eAAe,+DAQhD,CAAC"}