@antelopejs/dms 0.0.1

package/dist/validation/onboarding/register-admin.schema.d.ts

@@ -0,0 +1,22 @@
+import * as z from "zod";
+export declare const onboardingRegisterAdminSchema: z.ZodEffects<z.ZodObject<{
+    email: z.ZodString;
+    name: z.ZodString;
+    password: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    email: string;
+    password: string;
+}, {
+    name: string;
+    email: string;
+    password: string;
+}>, {
+    email: string;
+    name: string;
+    password: string;
+}, {
+    name: string;
+    email: string;
+    password: string;
+}>;

package/dist/validation/onboarding/register-admin.schema.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onboardingRegisterAdminSchema = void 0;
+const striptags_1 = __importDefault(require("striptags"));
+const z = __importStar(require("zod"));
+const password_1 = require("../password");
+exports.onboardingRegisterAdminSchema = z
+    .object({
+    email: z.string().trim().email(),
+    name: z.string().trim().min(1),
+    password: password_1.passwordSchema,
+})
+    .transform((data) => ({
+    email: (0, striptags_1.default)(data.email),
+    name: (0, striptags_1.default)(data.name),
+    password: data.password,
+}));
+//# sourceMappingURL=register-admin.schema.js.map

package/dist/validation/onboarding/register-admin.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-admin.schema.js","sourceRoot":"","sources":["../../../src/validation/onboarding/register-admin.schema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0DAAkC;AAClC,uCAAyB;AAEzB,0CAA6C;AAEhC,QAAA,6BAA6B,GAAG,CAAC;KAC3C,MAAM,CAAC;IACN,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE;IAChC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9B,QAAQ,EAAE,yBAAc;CACzB,CAAC;KACD,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IACpB,KAAK,EAAE,IAAA,mBAAS,EAAC,IAAI,CAAC,KAAK,CAAC;IAC5B,IAAI,EAAE,IAAA,mBAAS,EAAC,IAAI,CAAC,IAAI,CAAC;IAC1B,QAAQ,EAAE,IAAI,CAAC,QAAQ;CACxB,CAAC,CAAC,CAAC"}

package/dist/validation/password.d.ts

@@ -0,0 +1,3 @@
+import * as z from "zod";
+export declare const PASSWORD_REGEX: RegExp;
+export declare const passwordSchema: z.ZodString;

package/dist/validation/password.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.passwordSchema = exports.PASSWORD_REGEX = void 0;
+const z = __importStar(require("zod"));
+exports.PASSWORD_REGEX = /^(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]+$/;
+exports.passwordSchema = z.string().min(8).regex(exports.PASSWORD_REGEX);
+//# sourceMappingURL=password.js.map

package/dist/validation/password.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"password.js","sourceRoot":"","sources":["../../src/validation/password.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uCAAyB;AAEZ,QAAA,cAAc,GACzB,wDAAwD,CAAC;AAE9C,QAAA,cAAc,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,sBAAc,CAAC,CAAC"}

package/dist/validation/user-notification-preferences.schema.d.ts

@@ -0,0 +1,2 @@
+import * as z from "zod";
+export declare const userNotificationPreferencesSchema: z.ZodRecord<z.ZodString, z.ZodBoolean>;

package/dist/validation/user-notification-preferences.schema.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userNotificationPreferencesSchema = void 0;
+const z = __importStar(require("zod"));
+exports.userNotificationPreferencesSchema = z.record(z.string(), z.boolean());
+//# sourceMappingURL=user-notification-preferences.schema.js.map

package/dist/validation/user-notification-preferences.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-notification-preferences.schema.js","sourceRoot":"","sources":["../../src/validation/user-notification-preferences.schema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,uCAAyB;AAEZ,QAAA,iCAAiC,GAAG,CAAC,CAAC,MAAM,CACvD,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,OAAO,EAAE,CACZ,CAAC"}

package/frontend-vue/.prettierrc

@@ -0,0 +1,10 @@
+{
+  "semi": true,
+  "singleQuote": false,
+  "trailingComma": "all",
+  "endOfLine": "auto",
+  "tabWidth": 2,
+  "printWidth": 80,
+  "plugins": ["prettier-plugin-tailwindcss"],
+  "htmlWhitespaceSensitivity": "ignore"
+}

package/frontend-vue/.vscode/settings.json

@@ -0,0 +1,42 @@
+{
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.formatOnSave": true,
+  "editor.formatOnPaste": true,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit"
+  },
+  "eslint.enable": true,
+  "eslint.validate": [
+    "javascript",
+    "javascriptreact",
+    "typescript",
+    "typescriptreact",
+    "vue"
+  ],
+  "eslint.workingDirectories": [
+    {
+      "mode": "auto"
+    }
+  ],
+  "[typescript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[javascript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[vue]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[json]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[jsonc]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[css]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "[scss]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  }
+}

package/frontend-vue/antelope.config.json

@@ -0,0 +1,5 @@
+{
+  "url": "http://127.0.0.1:5010",
+  "entry": "/dms/frontend",
+  "sitelayout": "/dms/sitelayout"
+}

package/frontend-vue/deferred-plugins.ts

@@ -0,0 +1,29 @@
+import {
+  type DmsAppContext,
+  type DmsPluginSetup,
+} from "#dms-inertia/frontend-module";
+import dmsMenuSyncPlugin from "./layers/dms-layout/app/plugins/dms-menu-sync.client";
+import commandPaletteNavigationPlugin from "./layers/dms-layout/app/plugins/command-palette-navigation.client";
+import commandPalettePersonalPagesPlugin from "./layers/dms-layout/app/plugins/command-palette-personal-pages.client";
+import commandPaletteQuickActionsPlugin from "./layers/dms-layout/app/plugins/command-palette-quick-actions.client";
+import commandPaletteSessionPlugin from "./layers/dms-layout/app/plugins/command-palette-session.client";
+import notificationStreamPlugin from "./layers/dms-layout/app/plugins/notification-stream.client";
+import profileSyncPlugin from "./layers/dms-layout/app/plugins/profile-sync.client";
+
+const deferredPlugins: DmsPluginSetup[] = [
+  dmsMenuSyncPlugin,
+  commandPaletteNavigationPlugin,
+  commandPalettePersonalPagesPlugin,
+  commandPaletteQuickActionsPlugin,
+  commandPaletteSessionPlugin,
+  notificationStreamPlugin,
+  profileSyncPlugin,
+];
+
+export async function installDeferredPlugins(
+  context: DmsAppContext,
+): Promise<void> {
+  for (const plugin of deferredPlugins) {
+    await context.runWithContext(() => plugin(context));
+  }
+}

package/frontend-vue/dms.email.ts

@@ -0,0 +1,13 @@
+import type { Component } from "vue";
+import defaults from "./layers/dms-layout/app/app.config";
+
+/** Branding shared with transactional templates, without the browser module. */
+export const appConfig = { branding: defaults.branding };
+
+interface EmailModule {
+  default: Component;
+}
+
+export const serverEmailTemplates = import.meta.glob<EmailModule>(
+  "./layers/**/app/emails/**/*.vue",
+);

package/frontend-vue/dms.frontend.ts

@@ -0,0 +1,190 @@
+import { defineAsyncComponent, type Component } from "vue";
+import {
+  type DmsFrontendModule,
+  useDmsAppConfig,
+} from "#dms-inertia/frontend-module";
+import { defu } from "defu";
+import appConfig from "./layers/dms-layout/app/app.config";
+import authMiddleware from "./layers/dms-auth/app/middleware/auth";
+import homepageRedirectMiddleware from "./layers/dms-layout/app/middleware/homepage-redirect.global";
+import moduleRoutingMiddleware from "./layers/dms-layout/app/middleware/module-routing.global";
+import pageLeaveGuardMiddleware from "./layers/dms-layout/app/middleware/page-leave-guard.global";
+import interfaceScalePlugin from "./layers/dms-layout/app/plugins/interface-scale";
+import languageSyncPlugin from "./layers/dms-layout/app/plugins/language-sync";
+import seoPlugin from "./layers/dms-layout/app/plugins/seo";
+import onboardingMiddleware from "./layers/dms-onboarding/app/middleware/onboarding.global";
+import registerPlugin from "./layers/dms-ui/app/plugins/register";
+import shortcutsPlugin from "./layers/dms-ui/app/plugins/shortcuts";
+import tableViewDisplaysPlugin from "./layers/dms-ui/app/plugins/table-view-displays.client";
+import "./layers/dms-layout/app/assets/css/main.css";
+import type {} from "./layers/dms-core/shared/types/runtime-config";
+import type {} from "./layers/dms-core/shared/types/app-config";
+
+interface VueModule {
+  default: Component;
+}
+
+type VueLoader = () => Promise<VueModule>;
+
+interface DmsPublicOptions {
+  dms?: {
+    baseURL?: string;
+  };
+}
+
+const components = import.meta.glob<VueModule>(
+  "./layers/**/app/{components,build/components}/**/*.vue",
+);
+const customPages = import.meta.glob<VueModule>(
+  "./layers/**/app/custom-pages/**/*.vue",
+);
+const dynamicPages = import.meta.glob<VueModule>(
+  "./layers/**/app/pages/**/*.vue",
+);
+const layouts = import.meta.glob<VueModule>(
+  "./layers/**/app/custom-layouts/**/*.vue",
+);
+const errorPages = import.meta.glob<VueModule>("./layers/**/app/error.vue");
+
+function pascalCase(path: string): string {
+  return path
+    .replace(/\.vue$/, "")
+    .split(/[./_-]+/)
+    .filter(Boolean)
+    .map((part) => `${part[0].toUpperCase()}${part.slice(1)}`)
+    .join("");
+}
+
+function componentName(path: string): string {
+  const relativePath = path.replace(
+    /^.*\/(?:components|build\/components)\//,
+    "",
+  );
+  return `Dms${pascalCase(relativePath.split("/").at(-1) ?? relativePath)}`;
+}
+
+function entryName(path: string, directory: string): string {
+  return path
+    .replace(new RegExp(`^.*\\/${directory}\\/`), "")
+    .replace(/\.vue$/, "");
+}
+
+function sortedEntries(
+  loaders: Record<string, VueLoader>,
+): Array<[string, VueLoader]> {
+  return Object.entries(loaders).sort(([left], [right]) =>
+    left.localeCompare(right),
+  );
+}
+
+function lazyComponent(loader: VueLoader): Component {
+  return defineAsyncComponent(async () => (await loader()).default);
+}
+
+function registerComponents(
+  sdk: Parameters<DmsFrontendModule["setup"]>[0],
+): void {
+  const names = new Map<string, string>();
+  for (const [path, loader] of sortedEntries(components)) {
+    const name = componentName(path);
+    const previousPath = names.get(name);
+    if (previousPath) {
+      throw new Error(
+        `Duplicate component name ${name}: ${previousPath}, ${path}`,
+      );
+    }
+    names.set(name, path);
+    sdk.registerComponent(name, lazyComponent(loader));
+  }
+}
+
+function registerEntries(
+  entries: Record<string, VueLoader>,
+  directory: string,
+  register: (name: string, component: Component, preload?: VueLoader) => void,
+): void {
+  sortedEntries(entries).forEach(([path, loader]) => {
+    register(entryName(path, directory), lazyComponent(loader), loader);
+  });
+}
+
+function registerCustomPages(
+  sdk: Parameters<DmsFrontendModule["setup"]>[0],
+): void {
+  sortedEntries(customPages).forEach(([path, loader]) => {
+    const name = entryName(path, "custom-pages").replace(/\/index$/, "");
+    const component = lazyComponent(loader);
+    sdk.registerPage(name, component, loader);
+    sdk.registerComponent(`Dms${pascalCase(name)}`, component);
+  });
+}
+
+function registerDeferredPlugins(
+  sdk: Parameters<DmsFrontendModule["setup"]>[0],
+): void {
+  sdk.registerPlugin(
+    (context) => {
+      context.hook("app:mounted", async () => {
+        const { installDeferredPlugins } = await import("./deferred-plugins");
+        await installDeferredPlugins(context);
+      });
+    },
+    { clientOnly: true },
+  );
+}
+
+function registerPlugins(sdk: Parameters<DmsFrontendModule["setup"]>[0]): void {
+  const clientOnly = { clientOnly: true };
+  if (import.meta.env.DEV) {
+    sdk.registerPlugin(async (context) => {
+      const plugin = await import(
+        "./layers/dms-layout/app/plugins/dms-dev-reload.client"
+      );
+      await plugin.default(context);
+    }, clientOnly);
+  }
+  sdk.registerPlugin(interfaceScalePlugin);
+  sdk.registerPlugin(languageSyncPlugin);
+  sdk.registerPlugin(seoPlugin);
+  sdk.registerPlugin(registerPlugin);
+  sdk.registerPlugin(shortcutsPlugin);
+  sdk.registerPlugin(tableViewDisplaysPlugin, clientOnly);
+  registerDeferredPlugins(sdk);
+}
+
+function registerMiddleware(
+  sdk: Parameters<DmsFrontendModule["setup"]>[0],
+): void {
+  const global = { global: true };
+  sdk.registerMiddleware("auth", authMiddleware);
+  sdk.registerMiddleware(
+    "homepage-redirect",
+    homepageRedirectMiddleware,
+    global,
+  );
+  sdk.registerMiddleware("module-routing", moduleRoutingMiddleware, global);
+  sdk.registerMiddleware("page-leave-guard", pageLeaveGuardMiddleware, global);
+  sdk.registerMiddleware("onboarding", onboardingMiddleware, global);
+}
+
+const frontendModule: DmsFrontendModule = {
+  setup(sdk) {
+    const publicOptions = sdk.options.public as DmsPublicOptions;
+    if (publicOptions.dms && typeof window !== "undefined")
+      publicOptions.dms.baseURL = window.location.origin;
+    const runtimeAppConfig = useDmsAppConfig();
+    Object.assign(runtimeAppConfig, defu(runtimeAppConfig, appConfig));
+    registerPlugins(sdk);
+    registerMiddleware(sdk);
+    registerComponents(sdk);
+    registerCustomPages(sdk);
+    registerEntries(dynamicPages, "pages", sdk.registerDynamicPage);
+    registerEntries(layouts, "custom-layouts", sdk.registerLayout);
+    sortedEntries(errorPages).forEach(([, loader]) => {
+      sdk.registerErrorPage(lazyComponent(loader), loader);
+    });
+    sdk.provide("dmsPublicConfig", sdk.options.public);
+  },
+};
+
+export default frontendModule;

package/frontend-vue/eslint.config.mjs

@@ -0,0 +1,50 @@
+// @ts-check
+import eslint from "@eslint/js";
+import typescript from "@typescript-eslint/eslint-plugin";
+import typescriptParser from "@typescript-eslint/parser";
+import vue from "eslint-plugin-vue";
+import globals from "globals";
+
+const sourceFiles = ["**/*.{js,mjs,cjs,ts,vue}"];
+
+export default [
+  { ignores: ["dist/**", "node_modules/**"] },
+  eslint.configs.recommended,
+  ...vue.configs["flat/recommended"],
+  {
+    files: ["**/*.{ts,mts,cts}"],
+    languageOptions: { parser: typescriptParser },
+  },
+  {
+    files: sourceFiles,
+    languageOptions: {
+      globals: { ...globals.browser, ...globals.node },
+      parserOptions: {
+        parser: typescriptParser,
+        sourceType: "module",
+      },
+    },
+    plugins: { "@typescript-eslint": typescript },
+    rules: {
+      "no-redeclare": "off",
+      "no-undef": "off",
+      "no-unused-vars": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          argsIgnorePattern: "^_",
+          varsIgnorePattern: "^_",
+          caughtErrorsIgnorePattern: "^_",
+        },
+      ],
+      "vue/attributes-order": "off",
+      "vue/html-indent": "off",
+      "vue/html-self-closing": "off",
+      "vue/max-attributes-per-line": "off",
+      "vue/multi-word-component-names": "off",
+      "vue/require-default-prop": "off",
+      "vue/singleline-html-element-content-newline": "off",
+    },
+  },
+];

package/frontend-vue/i18n.config.ts

@@ -0,0 +1,3 @@
+export default {
+  fallbackLocale: "en",
+};

package/frontend-vue/layers/dms-auth/app/components/OAuthButtons.vue

@@ -0,0 +1,58 @@
+<script setup lang="ts">
+interface Props {
+  note?: string;
+}
+
+defineProps<Props>();
+
+const config = useDmsRuntimeConfig();
+const route = useDmsRoute();
+const { locale } = useI18n();
+
+const providers = computed(() => config.public.dms.oauthProviders ?? []);
+
+function appendQueryParam(
+  query: URLSearchParams,
+  key: string,
+  value: unknown,
+): void {
+  if (typeof value === "string" && value) {
+    query.set(key, value);
+  }
+}
+
+function startUrl(providerId: string): string {
+  const query = new URLSearchParams({ language: locale.value });
+  appendQueryParam(query, "redirect", route.query.redirect);
+  appendQueryParam(query, "invite", route.query.token);
+
+  return `/auth/oauth/${providerId}/start?${query.toString()}`;
+}
+</script>
+
+<template>
+  <div v-if="providers.length" class="space-y-4 pb-7">
+    <UButton
+      v-for="provider in providers"
+      :key="provider.id"
+      :to="startUrl(provider.id)"
+      :icon="provider.icon"
+      :label="$t('page.auth.oauth.continue_with', { provider: provider.label })"
+      color="neutral"
+      variant="outline"
+      size="lg"
+      external
+      block
+    />
+
+    <p v-if="note" class="text-muted text-center text-xs">
+      {{ note }}
+    </p>
+
+    <USeparator>
+      <span class="text-dimmed text-xs font-medium uppercase">
+        {{ $t("page.auth.oauth.separator") }}
+      </span>
+    </USeparator>
+  </div>
+</template>

package/frontend-vue/layers/dms-auth/app/composables/useAuthLinks.ts

@@ -0,0 +1,33 @@
+export interface AuthLink {
+  id: string;
+  page: string;
+  label: string;
+  to: string;
+  order: number;
+}
+
+const links = ref<AuthLink[]>([]);
+
+function compareByOrder(a: AuthLink, b: AuthLink): number {
+  return a.order - b.order;
+}
+
+export function registerAuthLink(link: AuthLink): void {
+  const existingIndex = links.value.findIndex((entry) => entry.id === link.id);
+
+  if (existingIndex === -1) {
+    links.value = [...links.value, link];
+    return;
+  }
+
+  const next = [...links.value];
+  next[existingIndex] = link;
+  links.value = next;
+}
+
+export function useAuthLinks(page: string) {
+  const sortedLinks = computed<AuthLink[]>(() =>
+    links.value.filter((link) => link.page === page).sort(compareByOrder),
+  );
+  return { links: sortedLinks };
+}

package/frontend-vue/layers/dms-auth/app/composables/useCooldown.ts

@@ -0,0 +1,23 @@
+const COOLDOWN_INTERVAL_MS = 1000;
+
+export function useCooldown(duration: number) {
+  const cooldown = ref<number>(duration);
+  const cooldownInterval = ref<ReturnType<typeof setInterval>>();
+
+  function startCooldown() {
+    cooldown.value = duration;
+
+    if (cooldownInterval.value) {
+      clearInterval(cooldownInterval.value);
+    }
+
+    cooldownInterval.value = setInterval(() => {
+      cooldown.value--;
+      if (cooldown.value <= 0) {
+        clearInterval(cooldownInterval.value);
+      }
+    }, COOLDOWN_INTERVAL_MS);
+  }
+
+  return { cooldown, startCooldown };
+}