@baseplate-dev/react-generators 0.2.6 → 0.3.0

package/dist/generators/auth/auth-errors/auth-errors.generator.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Provides a set of errors for authentication.
+ */
+export declare const authErrorsGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{}, {
+    paths: import("@baseplate-dev/sync").GeneratorTask<{
+        authAuthErrorsPaths: import("@baseplate-dev/sync").ProviderExport<import("./generated/template-paths.js").AuthAuthErrorsPaths>;
+    }, {
+        packageInfo: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").PackageInfoProvider>;
+    }, undefined>;
+    renderers: import("@baseplate-dev/sync").GeneratorTask<{
+        authAuthErrorsRenderers: import("@baseplate-dev/sync").ProviderExport<import("./generated/template-renderers.js").AuthAuthErrorsRenderers>;
+    }, {
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").AuthAuthErrorsPaths>;
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+    }, undefined>;
+    imports: import("@baseplate-dev/sync").GeneratorTask<{
+        authErrorsImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            InvalidRoleError: {};
+        }>>;
+    }, {
+        paths: import("@baseplate-dev/sync").ProviderType<import("./generated/template-paths.js").AuthAuthErrorsPaths>;
+    }, undefined>;
+    main: import("@baseplate-dev/sync").GeneratorTask<any, {
+        renderers: import("@baseplate-dev/sync").ProviderType<import("./generated/template-renderers.js").AuthAuthErrorsRenderers>;
+    }, any>;
+    errorComponent: import("@baseplate-dev/sync").GeneratorTask<any, {
+        reactRouterConfig: import("@baseplate-dev/sync").ProviderType<Omit<import("@baseplate-dev/utils").FieldMap<{
+            routerSetupFragments: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/core-generators").TsCodeFragment>;
+            routerBodyFragments: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/core-generators").TsCodeFragment>;
+            rootLayoutComponent: import("@baseplate-dev/utils").ScalarContainer<import("@baseplate-dev/core-generators").TsCodeFragment | undefined>;
+            rootContextFields: import("@baseplate-dev/utils").NamedArrayFieldContainer<import("#src/generators/core/index.js").RootRouteContextField>;
+            errorComponentHeaderFragments: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/core-generators").TsCodeFragment>;
+            errorComponentBodyFragments: import("@baseplate-dev/utils").MapContainer<string, import("@baseplate-dev/core-generators").TsCodeFragment>;
+        }>, "getValues">>;
+        authHooksImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            SessionData: {
+                isTypeOnly: true;
+            };
+            useCurrentUser: {};
+            useLogOut: {};
+            useRequiredUserId: {};
+            useSession: {};
+            AuthRole: {
+                isTypeOnly: true;
+            };
+        }>>;
+        reactComponentsImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            AddOptionRequiredFields: {
+                isTypeOnly: true;
+            };
+            Alert: {};
+            AlertDescription: {};
+            AlertTitle: {};
+            Button: {};
+            buttonVariants: {};
+            Calendar: {};
+            Card: {};
+            CardContent: {};
+            CardDescription: {};
+            CardFooter: {};
+            CardHeader: {};
+            CardTitle: {};
+            Checkbox: {};
+            CheckboxField: {};
+            CheckboxFieldController: {};
+            CheckedInput: {};
+            CircularProgress: {};
+            cn: {};
+            Combobox: {};
+            ComboboxField: {};
+            ComboboxFieldController: {};
+            ConfirmDialog: {};
+            DatePickerField: {};
+            DatePickerFieldController: {};
+            DateTimePickerField: {};
+            DateTimePickerFieldController: {};
+            Dialog: {};
+            DialogClose: {};
+            DialogContent: {};
+            DialogDescription: {};
+            DialogFooter: {};
+            DialogHeader: {};
+            DialogOverlay: {};
+            DialogPortal: {};
+            DialogTitle: {};
+            DialogTrigger: {};
+            DialogWidth: {
+                isTypeOnly: true;
+            };
+            EmptyDisplay: {};
+            ErrorableLoader: {};
+            ErrorDisplay: {};
+            FormControl: {};
+            FormDescription: {};
+            FormFieldProps: {
+                isTypeOnly: true;
+            };
+            FormItem: {};
+            FormLabel: {};
+            FormMessage: {};
+            IconElement: {
+                isTypeOnly: true;
+            };
+            Input: {};
+            InputField: {};
+            InputFieldController: {};
+            inputVariants: {};
+            Label: {};
+            LinkButton: {};
+            Loader: {};
+            mergeRefs: {};
+            Modal: {};
+            MultiSelectOptionProps: {
+                isTypeOnly: true;
+            };
+            NavigationMenu: {};
+            NavigationMenuContent: {};
+            NavigationMenuIndicator: {};
+            NavigationMenuItem: {};
+            NavigationMenuItemWithLink: {};
+            NavigationMenuLink: {};
+            NavigationMenuList: {};
+            NavigationMenuTrigger: {};
+            navigationMenuTriggerStyle: {};
+            NavigationMenuViewport: {};
+            NotFoundCard: {};
+            Popover: {};
+            PopoverAnchor: {};
+            PopoverContent: {};
+            PopoverTrigger: {};
+            ReactDatePickerInput: {};
+            ReactSelectInput: {};
+            ScrollArea: {};
+            Select: {};
+            selectCheckVariants: {};
+            selectContentVariants: {};
+            SelectField: {};
+            SelectFieldController: {};
+            SelectInput: {};
+            selectItemVariants: {};
+            SelectOptionProps: {
+                isTypeOnly: true;
+            };
+            selectTriggerVariants: {};
+            SidebarLayout: {};
+            SidebarLayoutContent: {};
+            SidebarLayoutSidebar: {};
+            Switch: {};
+            SwitchField: {};
+            SwitchFieldController: {};
+            Table: {};
+            TableBody: {};
+            TableCaption: {};
+            TableCell: {};
+            TableFooter: {};
+            TableHead: {};
+            TableHeader: {};
+            TableRow: {};
+            Textarea: {};
+            TextareaField: {};
+            TextareaFieldController: {};
+            TextAreaInput: {};
+            TextInput: {};
+            Toaster: {};
+            useConfirmDialog: {};
+            UseConfirmDialogRequestOptions: {
+                isTypeOnly: true;
+            };
+            useConfirmDialogState: {};
+            useControlledState: {};
+            useControllerMerged: {};
+        }>>;
+        authErrorsImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            InvalidRoleError: {};
+        }>>;
+    }, any>;
+}>;
+//# sourceMappingURL=auth-errors.generator.d.ts.map

package/dist/generators/auth/auth-errors/auth-errors.generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-errors.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/auth/auth-errors/auth-errors.generator.ts"],"names":[],"mappings":"AAmBA;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsE9B,CAAC"}

package/dist/generators/auth/auth-errors/auth-errors.generator.js

@@ -0,0 +1,70 @@
+import { tsImportBuilder, tsTemplate, tsTemplateWithImports, } from '@baseplate-dev/core-generators';
+import { createGenerator, createGeneratorTask } from '@baseplate-dev/sync';
+import { z } from 'zod';
+import { reactComponentsImportsProvider, reactRouterConfigProvider, } from '#src/generators/core/index.js';
+import { authHooksImportsProvider } from '../_providers/auth-hooks.js';
+import { AUTH_AUTH_ERRORS_GENERATED as GENERATED_TEMPLATES } from './generated/index.js';
+import { authErrorsImportsProvider } from './generated/ts-import-providers.js';
+const descriptorSchema = z.object({});
+/**
+ * Provides a set of errors for authentication.
+ */
+export const authErrorsGenerator = createGenerator({
+    name: 'auth/auth-errors',
+    generatorFileUrl: import.meta.url,
+    descriptorSchema,
+    buildTasks: () => ({
+        paths: GENERATED_TEMPLATES.paths.task,
+        renderers: GENERATED_TEMPLATES.renderers.task,
+        imports: GENERATED_TEMPLATES.imports.task,
+        main: createGeneratorTask({
+            dependencies: {
+                renderers: GENERATED_TEMPLATES.renderers.provider,
+            },
+            run({ renderers }) {
+                return {
+                    build: async (builder) => {
+                        await builder.apply(renderers.mainGroup.render({
+                            variables: {},
+                        }));
+                    },
+                };
+            },
+        }),
+        errorComponent: createGeneratorTask({
+            dependencies: {
+                reactRouterConfig: reactRouterConfigProvider,
+                authHooksImports: authHooksImportsProvider,
+                reactComponentsImports: reactComponentsImportsProvider,
+                authErrorsImports: authErrorsImportsProvider,
+            },
+            run({ reactRouterConfig, authHooksImports, reactComponentsImports, authErrorsImports, }) {
+                reactRouterConfig.errorComponentHeaderFragments.set('auth-errors', tsTemplate `const logout = ${authHooksImports.useLogOut.fragment()}()`);
+                reactRouterConfig.errorComponentBodyFragments.set('auth-errors', tsTemplateWithImports([
+                    tsImportBuilder(['Link']).from('@tanstack/react-router'),
+                    reactComponentsImports.ErrorDisplay.declaration(),
+                    reactComponentsImports.Button.declaration(),
+                    authErrorsImports.InvalidRoleError.declaration(),
+                ]) `if (error instanceof InvalidRoleError) {
+            return (
+              <ErrorDisplay
+                header="Access Denied"
+                error="You are not authorized to access this page. Please contact support if you believe this is an error."
+                actions={
+                  <div className="flex gap-2">
+                    <Link to="/">
+                      <Button>Return Home</Button>
+                    </Link>
+                    <Button variant="secondary" onClick={logout}>
+                      Logout
+                    </Button>
+                  </div>
+                }
+              />
+            );
+          }`);
+            },
+        }),
+    }),
+});
+//# sourceMappingURL=auth-errors.generator.js.map

package/dist/generators/auth/auth-errors/auth-errors.generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-errors.generator.js","sourceRoot":"","sources":["../../../../src/generators/auth/auth-errors/auth-errors.generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,UAAU,EACV,qBAAqB,GACtB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC3E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EACL,8BAA8B,EAC9B,yBAAyB,GAC1B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,EAAE,0BAA0B,IAAI,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAE/E,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAEtC;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,eAAe,CAAC;IACjD,IAAI,EAAE,kBAAkB;IACxB,gBAAgB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG;IACjC,gBAAgB;IAChB,UAAU,EAAE,GAAG,EAAE,CAAC,CAAC;QACjB,KAAK,EAAE,mBAAmB,CAAC,KAAK,CAAC,IAAI;QACrC,SAAS,EAAE,mBAAmB,CAAC,SAAS,CAAC,IAAI;QAC7C,OAAO,EAAE,mBAAmB,CAAC,OAAO,CAAC,IAAI;QACzC,IAAI,EAAE,mBAAmB,CAAC;YACxB,YAAY,EAAE;gBACZ,SAAS,EAAE,mBAAmB,CAAC,SAAS,CAAC,QAAQ;aAClD;YACD,GAAG,CAAC,EAAE,SAAS,EAAE;gBACf,OAAO;oBACL,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;wBACvB,MAAM,OAAO,CAAC,KAAK,CACjB,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC;4BACzB,SAAS,EAAE,EAAE;yBACd,CAAC,CACH,CAAC;oBACJ,CAAC;iBACF,CAAC;YACJ,CAAC;SACF,CAAC;QACF,cAAc,EAAE,mBAAmB,CAAC;YAClC,YAAY,EAAE;gBACZ,iBAAiB,EAAE,yBAAyB;gBAC5C,gBAAgB,EAAE,wBAAwB;gBAC1C,sBAAsB,EAAE,8BAA8B;gBACtD,iBAAiB,EAAE,yBAAyB;aAC7C;YACD,GAAG,CAAC,EACF,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACtB,iBAAiB,GAClB;gBACC,iBAAiB,CAAC,6BAA6B,CAAC,GAAG,CACjD,aAAa,EACb,UAAU,CAAA,kBAAkB,gBAAgB,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CACtE,CAAC;gBACF,iBAAiB,CAAC,2BAA2B,CAAC,GAAG,CAC/C,aAAa,EACb,qBAAqB,CAAC;oBACpB,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,wBAAwB,CAAC;oBACxD,sBAAsB,CAAC,YAAY,CAAC,WAAW,EAAE;oBACjD,sBAAsB,CAAC,MAAM,CAAC,WAAW,EAAE;oBAC3C,iBAAiB,CAAC,gBAAgB,CAAC,WAAW,EAAE;iBACjD,CAAC,CAAA;;;;;;;;;;;;;;;;;YAiBA,CACH,CAAC;YACJ,CAAC;SACF,CAAC;KACH,CAAC;CACH,CAAC,CAAC"}

package/dist/generators/auth/auth-errors/generated/index.d.ts

@@ -0,0 +1,34 @@
+export declare const AUTH_AUTH_ERRORS_GENERATED: {
+    imports: {
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            authErrorsImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+                InvalidRoleError: {};
+            }>>;
+        }, {
+            paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").AuthAuthErrorsPaths>;
+        }, undefined>;
+    };
+    paths: {
+        provider: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").AuthAuthErrorsPaths>;
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            authAuthErrorsPaths: import("@baseplate-dev/sync").ProviderExport<import("./template-paths.js").AuthAuthErrorsPaths>;
+        }, {
+            packageInfo: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").PackageInfoProvider>;
+        }, undefined>;
+    };
+    renderers: {
+        provider: import("@baseplate-dev/sync").ProviderType<import("./template-renderers.js").AuthAuthErrorsRenderers>;
+        task: import("@baseplate-dev/sync").GeneratorTask<{
+            authAuthErrorsRenderers: import("@baseplate-dev/sync").ProviderExport<import("./template-renderers.js").AuthAuthErrorsRenderers>;
+        }, {
+            paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").AuthAuthErrorsPaths>;
+            typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+        }, undefined>;
+    };
+    templates: {
+        mainGroup: {
+            authErrors: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+        };
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/auth/auth-errors/generated/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-errors/generated/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKtC,CAAC"}

package/dist/generators/auth/auth-errors/generated/index.js

@@ -0,0 +1,11 @@
+import { AUTH_AUTH_ERRORS_PATHS } from './template-paths.js';
+import { AUTH_AUTH_ERRORS_RENDERERS } from './template-renderers.js';
+import { AUTH_AUTH_ERRORS_IMPORTS } from './ts-import-providers.js';
+import { AUTH_AUTH_ERRORS_TEMPLATES } from './typed-templates.js';
+export const AUTH_AUTH_ERRORS_GENERATED = {
+    imports: AUTH_AUTH_ERRORS_IMPORTS,
+    paths: AUTH_AUTH_ERRORS_PATHS,
+    renderers: AUTH_AUTH_ERRORS_RENDERERS,
+    templates: AUTH_AUTH_ERRORS_TEMPLATES,
+};
+//# sourceMappingURL=index.js.map

package/dist/generators/auth/auth-errors/generated/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-errors/generated/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAElE,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,OAAO,EAAE,wBAAwB;IACjC,KAAK,EAAE,sBAAsB;IAC7B,SAAS,EAAE,0BAA0B;IACrC,SAAS,EAAE,0BAA0B;CACtC,CAAC"}

package/dist/generators/auth/auth-errors/generated/template-paths.d.ts

@@ -0,0 +1,12 @@
+export interface AuthAuthErrorsPaths {
+    authErrors: string;
+}
+export declare const AUTH_AUTH_ERRORS_PATHS: {
+    provider: import("@baseplate-dev/sync").ProviderType<AuthAuthErrorsPaths>;
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        authAuthErrorsPaths: import("@baseplate-dev/sync").ProviderExport<AuthAuthErrorsPaths>;
+    }, {
+        packageInfo: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").PackageInfoProvider>;
+    }, undefined>;
+};
+//# sourceMappingURL=template-paths.d.ts.map

package/dist/generators/auth/auth-errors/generated/template-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-paths.d.ts","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-errors/generated/template-paths.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,mBAAmB;IAClC,UAAU,EAAE,MAAM,CAAC;CACpB;AAoBD,eAAO,MAAM,sBAAsB;;;;;;;CAGlC,CAAC"}

package/dist/generators/auth/auth-errors/generated/template-paths.js

@@ -0,0 +1,20 @@
+import { packageInfoProvider } from '@baseplate-dev/core-generators';
+import { createGeneratorTask, createProviderType } from '@baseplate-dev/sync';
+const authAuthErrorsPaths = createProviderType('auth-auth-errors-paths');
+const authAuthErrorsPathsTask = createGeneratorTask({
+    dependencies: { packageInfo: packageInfoProvider },
+    exports: { authAuthErrorsPaths: authAuthErrorsPaths.export() },
+    run({ packageInfo }) {
+        const srcRoot = packageInfo.getPackageSrcPath();
+        return {
+            providers: {
+                authAuthErrorsPaths: { authErrors: `${srcRoot}/utils/auth-errors.ts` },
+            },
+        };
+    },
+});
+export const AUTH_AUTH_ERRORS_PATHS = {
+    provider: authAuthErrorsPaths,
+    task: authAuthErrorsPathsTask,
+};
+//# sourceMappingURL=template-paths.js.map

package/dist/generators/auth/auth-errors/generated/template-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-paths.js","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-errors/generated/template-paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAM9E,MAAM,mBAAmB,GAAG,kBAAkB,CAC5C,wBAAwB,CACzB,CAAC;AAEF,MAAM,uBAAuB,GAAG,mBAAmB,CAAC;IAClD,YAAY,EAAE,EAAE,WAAW,EAAE,mBAAmB,EAAE;IAClD,OAAO,EAAE,EAAE,mBAAmB,EAAE,mBAAmB,CAAC,MAAM,EAAE,EAAE;IAC9D,GAAG,CAAC,EAAE,WAAW,EAAE;QACjB,MAAM,OAAO,GAAG,WAAW,CAAC,iBAAiB,EAAE,CAAC;QAEhD,OAAO;YACL,SAAS,EAAE;gBACT,mBAAmB,EAAE,EAAE,UAAU,EAAE,GAAG,OAAO,uBAAuB,EAAE;aACvE;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,QAAQ,EAAE,mBAAmB;IAC7B,IAAI,EAAE,uBAAuB;CAC9B,CAAC"}

package/dist/generators/auth/auth-errors/generated/template-renderers.d.ts

@@ -0,0 +1,18 @@
+import type { RenderTsTemplateGroupActionInput } from '@baseplate-dev/core-generators';
+import type { BuilderAction } from '@baseplate-dev/sync';
+import { AUTH_AUTH_ERRORS_TEMPLATES } from './typed-templates.js';
+export interface AuthAuthErrorsRenderers {
+    mainGroup: {
+        render: (options: Omit<RenderTsTemplateGroupActionInput<typeof AUTH_AUTH_ERRORS_TEMPLATES.mainGroup>, 'importMapProviders' | 'group' | 'paths' | 'generatorPaths'>) => BuilderAction;
+    };
+}
+export declare const AUTH_AUTH_ERRORS_RENDERERS: {
+    provider: import("@baseplate-dev/sync").ProviderType<AuthAuthErrorsRenderers>;
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        authAuthErrorsRenderers: import("@baseplate-dev/sync").ProviderExport<AuthAuthErrorsRenderers>;
+    }, {
+        paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").AuthAuthErrorsPaths>;
+        typescriptFile: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").TypescriptFileProvider>;
+    }, undefined>;
+};
+//# sourceMappingURL=template-renderers.d.ts.map

package/dist/generators/auth/auth-errors/generated/template-renderers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-renderers.d.ts","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-errors/generated/template-renderers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,gCAAgC,CAAC;AACvF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAMzD,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAElE,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE;QACT,MAAM,EAAE,CACN,OAAO,EAAE,IAAI,CACX,gCAAgC,CAC9B,OAAO,0BAA0B,CAAC,SAAS,CAC5C,EACD,oBAAoB,GAAG,OAAO,GAAG,OAAO,GAAG,gBAAgB,CAC5D,KACE,aAAa,CAAC;KACpB,CAAC;CACH;AA8BD,eAAO,MAAM,0BAA0B;;;;;;;;CAGtC,CAAC"}

package/dist/generators/auth/auth-errors/generated/template-renderers.js

@@ -0,0 +1,32 @@
+import { typescriptFileProvider } from '@baseplate-dev/core-generators';
+import { createGeneratorTask, createProviderType } from '@baseplate-dev/sync';
+import { AUTH_AUTH_ERRORS_PATHS } from './template-paths.js';
+import { AUTH_AUTH_ERRORS_TEMPLATES } from './typed-templates.js';
+const authAuthErrorsRenderers = createProviderType('auth-auth-errors-renderers');
+const authAuthErrorsRenderersTask = createGeneratorTask({
+    dependencies: {
+        paths: AUTH_AUTH_ERRORS_PATHS.provider,
+        typescriptFile: typescriptFileProvider,
+    },
+    exports: { authAuthErrorsRenderers: authAuthErrorsRenderers.export() },
+    run({ paths, typescriptFile }) {
+        return {
+            providers: {
+                authAuthErrorsRenderers: {
+                    mainGroup: {
+                        render: (options) => typescriptFile.renderTemplateGroup({
+                            group: AUTH_AUTH_ERRORS_TEMPLATES.mainGroup,
+                            paths,
+                            ...options,
+                        }),
+                    },
+                },
+            },
+        };
+    },
+});
+export const AUTH_AUTH_ERRORS_RENDERERS = {
+    provider: authAuthErrorsRenderers,
+    task: authAuthErrorsRenderersTask,
+};
+//# sourceMappingURL=template-renderers.js.map

package/dist/generators/auth/auth-errors/generated/template-renderers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-renderers.js","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-errors/generated/template-renderers.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9E,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAelE,MAAM,uBAAuB,GAAG,kBAAkB,CAChD,4BAA4B,CAC7B,CAAC;AAEF,MAAM,2BAA2B,GAAG,mBAAmB,CAAC;IACtD,YAAY,EAAE;QACZ,KAAK,EAAE,sBAAsB,CAAC,QAAQ;QACtC,cAAc,EAAE,sBAAsB;KACvC;IACD,OAAO,EAAE,EAAE,uBAAuB,EAAE,uBAAuB,CAAC,MAAM,EAAE,EAAE;IACtE,GAAG,CAAC,EAAE,KAAK,EAAE,cAAc,EAAE;QAC3B,OAAO;YACL,SAAS,EAAE;gBACT,uBAAuB,EAAE;oBACvB,SAAS,EAAE;wBACT,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE,CAClB,cAAc,CAAC,mBAAmB,CAAC;4BACjC,KAAK,EAAE,0BAA0B,CAAC,SAAS;4BAC3C,KAAK;4BACL,GAAG,OAAO;yBACX,CAAC;qBACL;iBACF;aACF;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,0BAA0B,GAAG;IACxC,QAAQ,EAAE,uBAAuB;IACjC,IAAI,EAAE,2BAA2B;CAClC,CAAC"}

package/dist/generators/auth/auth-errors/generated/ts-import-providers.d.ts

@@ -0,0 +1,19 @@
+import type { TsImportMapProviderFromSchema } from '@baseplate-dev/core-generators';
+declare const authErrorsImportsSchema: {
+    InvalidRoleError: {};
+};
+export type AuthErrorsImportsProvider = TsImportMapProviderFromSchema<typeof authErrorsImportsSchema>;
+export declare const authErrorsImportsProvider: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+    InvalidRoleError: {};
+}>>;
+export declare const AUTH_AUTH_ERRORS_IMPORTS: {
+    task: import("@baseplate-dev/sync").GeneratorTask<{
+        authErrorsImports: import("@baseplate-dev/sync").ProviderExport<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
+            InvalidRoleError: {};
+        }>>;
+    }, {
+        paths: import("@baseplate-dev/sync").ProviderType<import("./template-paths.js").AuthAuthErrorsPaths>;
+    }, undefined>;
+};
+export {};
+//# sourceMappingURL=ts-import-providers.d.ts.map

package/dist/generators/auth/auth-errors/generated/ts-import-providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-import-providers.d.ts","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-errors/generated/ts-import-providers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,gCAAgC,CAAC;AAcpF,QAAA,MAAM,uBAAuB;;CAE3B,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,6BAA6B,CACnE,OAAO,uBAAuB,CAC/B,CAAC;AAEF,eAAO,MAAM,yBAAyB;;GACwC,CAAC;AAoB/E,eAAO,MAAM,wBAAwB;;;;;;;;CAEpC,CAAC"}

package/dist/generators/auth/auth-errors/generated/ts-import-providers.js

@@ -0,0 +1,28 @@
+import { createTsImportMap, createTsImportMapSchema, packageScope, } from '@baseplate-dev/core-generators';
+import { createGeneratorTask, createReadOnlyProviderType, } from '@baseplate-dev/sync';
+import { AUTH_AUTH_ERRORS_PATHS } from './template-paths.js';
+const authErrorsImportsSchema = createTsImportMapSchema({
+    InvalidRoleError: {},
+});
+export const authErrorsImportsProvider = createReadOnlyProviderType('auth-errors-imports');
+const authAuthErrorsImportsTask = createGeneratorTask({
+    dependencies: {
+        paths: AUTH_AUTH_ERRORS_PATHS.provider,
+    },
+    exports: {
+        authErrorsImports: authErrorsImportsProvider.export(packageScope),
+    },
+    run({ paths }) {
+        return {
+            providers: {
+                authErrorsImports: createTsImportMap(authErrorsImportsSchema, {
+                    InvalidRoleError: paths.authErrors,
+                }),
+            },
+        };
+    },
+});
+export const AUTH_AUTH_ERRORS_IMPORTS = {
+    task: authAuthErrorsImportsTask,
+};
+//# sourceMappingURL=ts-import-providers.js.map

package/dist/generators/auth/auth-errors/generated/ts-import-providers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-import-providers.js","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-errors/generated/ts-import-providers.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,YAAY,GACb,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,mBAAmB,EACnB,0BAA0B,GAC3B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,MAAM,uBAAuB,GAAG,uBAAuB,CAAC;IACtD,gBAAgB,EAAE,EAAE;CACrB,CAAC,CAAC;AAMH,MAAM,CAAC,MAAM,yBAAyB,GACpC,0BAA0B,CAA4B,qBAAqB,CAAC,CAAC;AAE/E,MAAM,yBAAyB,GAAG,mBAAmB,CAAC;IACpD,YAAY,EAAE;QACZ,KAAK,EAAE,sBAAsB,CAAC,QAAQ;KACvC;IACD,OAAO,EAAE;QACP,iBAAiB,EAAE,yBAAyB,CAAC,MAAM,CAAC,YAAY,CAAC;KAClE;IACD,GAAG,CAAC,EAAE,KAAK,EAAE;QACX,OAAO;YACL,SAAS,EAAE;gBACT,iBAAiB,EAAE,iBAAiB,CAAC,uBAAuB,EAAE;oBAC5D,gBAAgB,EAAE,KAAK,CAAC,UAAU;iBACnC,CAAC;aACH;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,IAAI,EAAE,yBAAyB;CAChC,CAAC"}

package/dist/generators/auth/auth-errors/generated/typed-templates.d.ts

@@ -0,0 +1,9 @@
+export declare const mainGroup: {
+    authErrors: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+};
+export declare const AUTH_AUTH_ERRORS_TEMPLATES: {
+    mainGroup: {
+        authErrors: import("@baseplate-dev/core-generators").TsTemplateFile<{}, {}, Record<never, Record<never, never>>>;
+    };
+};
+//# sourceMappingURL=typed-templates.d.ts.map

package/dist/generators/auth/auth-errors/generated/typed-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-templates.d.ts","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-errors/generated/typed-templates.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,SAAS;;CAAiB,CAAC;AAExC,eAAO,MAAM,0BAA0B;;;;CAAgB,CAAC"}

package/dist/generators/auth/auth-errors/generated/typed-templates.js

@@ -0,0 +1,16 @@
+import { createTsTemplateFile } from '@baseplate-dev/core-generators';
+import path from 'node:path';
+const authErrors = createTsTemplateFile({
+    fileOptions: { kind: 'singleton' },
+    group: 'main',
+    importMapProviders: {},
+    name: 'auth-errors',
+    projectExports: { InvalidRoleError: {} },
+    source: {
+        path: path.join(import.meta.dirname, '../templates/src/utils/auth-errors.ts'),
+    },
+    variables: {},
+});
+export const mainGroup = { authErrors };
+export const AUTH_AUTH_ERRORS_TEMPLATES = { mainGroup };
+//# sourceMappingURL=typed-templates.js.map

package/dist/generators/auth/auth-errors/generated/typed-templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-templates.js","sourceRoot":"","sources":["../../../../../src/generators/auth/auth-errors/generated/typed-templates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AACtE,OAAO,IAAI,MAAM,WAAW,CAAC;AAE7B,MAAM,UAAU,GAAG,oBAAoB,CAAC;IACtC,WAAW,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE;IAClC,KAAK,EAAE,MAAM;IACb,kBAAkB,EAAE,EAAE;IACtB,IAAI,EAAE,aAAa;IACnB,cAAc,EAAE,EAAE,gBAAgB,EAAE,EAAE,EAAE;IACxC,MAAM,EAAE;QACN,IAAI,EAAE,IAAI,CAAC,IAAI,CACb,MAAM,CAAC,IAAI,CAAC,OAAO,EACnB,uCAAuC,CACxC;KACF;IACD,SAAS,EAAE,EAAE;CACd,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,EAAE,UAAU,EAAE,CAAC;AAExC,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,SAAS,EAAE,CAAC"}

package/dist/generators/auth/auth-errors/index.d.ts

@@ -0,0 +1,4 @@
+export * from './auth-errors.generator.js';
+export type { AuthErrorsImportsProvider } from './generated/ts-import-providers.js';
+export { authErrorsImportsProvider } from './generated/ts-import-providers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/auth/auth-errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/generators/auth/auth-errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,YAAY,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AACpF,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC"}

package/dist/generators/auth/auth-errors/index.js

@@ -0,0 +1,3 @@
+export * from './auth-errors.generator.js';
+export { authErrorsImportsProvider } from './generated/ts-import-providers.js';
+//# sourceMappingURL=index.js.map

package/dist/generators/auth/auth-errors/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/generators/auth/auth-errors/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC"}

package/dist/generators/auth/auth-errors/templates/src/utils/auth-errors.ts

@@ -0,0 +1,8 @@
+// @ts-nocheck
+
+export class InvalidRoleError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'InvalidRoleError';
+  }
+}

package/dist/generators/auth/auth-identify/auth-identify.generator.d.ts

@@ -8,12 +8,14 @@ export declare const authIdentifyProvider: import("@baseplate-dev/sync").Provide
     identifyFragments: import("@baseplate-dev/utils").MapContainer<string, TsCodeFragment>;
 }>;
 export declare const authIdentifyGenerator: import("@baseplate-dev/sync").GeneratorBundleCreator<{}, {
-    authContext: import("@baseplate-dev/sync").GeneratorTask<undefined, {
+    authContext: import("@baseplate-dev/sync").GeneratorTask<any, {
         reactRouterConfig: import("@baseplate-dev/sync").ProviderType<Omit<import("@baseplate-dev/utils").FieldMap<{
             routerSetupFragments: import("@baseplate-dev/utils").MapContainer<string, TsCodeFragment>;
             routerBodyFragments: import("@baseplate-dev/utils").MapContainer<string, TsCodeFragment>;
             rootLayoutComponent: import("@baseplate-dev/utils").ScalarContainer<TsCodeFragment | undefined>;
             rootContextFields: import("@baseplate-dev/utils").NamedArrayFieldContainer<import("#src/generators/core/react-router/index.js").RootRouteContextField>;
+            errorComponentHeaderFragments: import("@baseplate-dev/utils").MapContainer<string, TsCodeFragment>;
+            errorComponentBodyFragments: import("@baseplate-dev/utils").MapContainer<string, TsCodeFragment>;
         }>, "getValues">>;
         authHooksImports: import("@baseplate-dev/sync").ProviderType<import("@baseplate-dev/core-generators").InferTsImportMapFromSchema<{
             SessionData: {
@@ -23,8 +25,11 @@ export declare const authIdentifyGenerator: import("@baseplate-dev/sync").Genera
             useLogOut: {};
             useRequiredUserId: {};
             useSession: {};
+            AuthRole: {
+                isTypeOnly: true;
+            };
         }>>;
-    }, undefined>;
+    }, any>;
     main: import("@baseplate-dev/sync").GeneratorTask<{
         authIdentify: import("@baseplate-dev/sync").ProviderExport<{
             identifyFragments: import("@baseplate-dev/utils").MapContainer<string, TsCodeFragment>;
@@ -35,6 +40,8 @@ export declare const authIdentifyGenerator: import("@baseplate-dev/sync").Genera
             routerBodyFragments: import("@baseplate-dev/utils").MapContainer<string, TsCodeFragment>;
             rootLayoutComponent: import("@baseplate-dev/utils").ScalarContainer<TsCodeFragment | undefined>;
             rootContextFields: import("@baseplate-dev/utils").NamedArrayFieldContainer<import("#src/generators/core/react-router/index.js").RootRouteContextField>;
+            errorComponentHeaderFragments: import("@baseplate-dev/utils").MapContainer<string, TsCodeFragment>;
+            errorComponentBodyFragments: import("@baseplate-dev/utils").MapContainer<string, TsCodeFragment>;
         }>, "getValues">>;
     }, any>;
 }>;

package/dist/generators/auth/auth-identify/auth-identify.generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth-identify.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/auth/auth-identify/auth-identify.generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAsB3E,QAAA,MAAM,YAAY;;CAEf,CAAC;AAEJ,MAAM,MAAM,oBAAoB,GAAG,8BAA8B,CAC/D,OAAO,YAAY,CACpB,CAAC;AAEF,eAAO,MAAM,oBAAoB;;EAC0B,CAAC;AAE5D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwChC,CAAC"}
+{"version":3,"file":"auth-identify.generator.d.ts","sourceRoot":"","sources":["../../../../src/generators/auth/auth-identify/auth-identify.generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,sBAAsB,CAAC;AAuB3E,QAAA,MAAM,YAAY;;CAEf,CAAC;AAEJ,MAAM,MAAM,oBAAoB,GAAG,8BAA8B,CAC/D,OAAO,YAAY,CACpB,CAAC;AAEF,eAAO,MAAM,oBAAoB;;EAC0B,CAAC;AAE5D,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqEhC,CAAC"}

package/dist/generators/auth/auth-identify/auth-identify.generator.js

@@ -1,9 +1,9 @@
-import { packageScope, TsCodeUtils, tsImportBuilder, } from '@baseplate-dev/core-generators';
+import { packageScope, TsCodeUtils, tsImportBuilder, tsTemplate, } from '@baseplate-dev/core-generators';
 import { createConfigFieldMap, createGenerator, createGeneratorTask, createProviderType, } from '@baseplate-dev/sync';
 import { createFieldMapSchemaBuilder } from '@baseplate-dev/utils';
 import { z } from 'zod';
 import { reactRouterConfigProvider } from '#src/generators/core/react-router/index.js';
-import { authContextTask } from '../_tasks/auth-context.js';
+import { authHooksImportsProvider } from '../_providers/auth-hooks.js';
 const descriptorSchema = z.object({});
 const configSchema = createFieldMapSchemaBuilder((t) => ({
     identifyFragments: t.map(),
@@ -14,7 +14,33 @@ export const authIdentifyGenerator = createGenerator({
     generatorFileUrl: import.meta.url,
     descriptorSchema,
     buildTasks: () => ({
-        authContext: authContextTask,
+        authContext: createGeneratorTask({
+            dependencies: {
+                reactRouterConfig: reactRouterConfigProvider,
+                authHooksImports: authHooksImportsProvider,
+            },
+            run({ reactRouterConfig, authHooksImports }) {
+                reactRouterConfig.routerSetupFragments.set('auth-context', tsTemplate `const session = ${authHooksImports.useSession.fragment()}();\nconst { userId } = session;`);
+                reactRouterConfig.rootContextFields.add({
+                    name: 'userId',
+                    type: tsTemplate `string | undefined`,
+                    optional: true,
+                    routerProviderInitializer: {
+                        code: tsTemplate `userId`,
+                        dependencies: ['userId'],
+                    },
+                });
+                reactRouterConfig.rootContextFields.add({
+                    name: 'session',
+                    type: authHooksImports.SessionData.typeFragment(),
+                    optional: false,
+                    routerProviderInitializer: {
+                        code: tsTemplate `session`,
+                        dependencies: ['session'],
+                    },
+                });
+            },
+        }),
         main: createGeneratorTask({
             dependencies: {
                 reactRouterConfig: reactRouterConfigProvider,