@antelopejs/dms 0.0.1

package/frontend-vue/layers/dms-core/app/composables/useTrailingDeduper.ts

@@ -0,0 +1,24 @@
+const DEDUPER_KEY_PREFIX = "$dmsTrailingDeduper:";
+
+interface DeduperHost {
+  [key: string]: unknown;
+}
+
+/**
+ * A {@link createTrailingDeduper} scoped to the current DMS app: one instance
+ * per client session, and one per request while server-rendering, so a trailing
+ * pass never runs in the continuation of another request's promise — where the
+ * state it writes, and the DMS app context its task needs, belong to someone else.
+ *
+ * Stored on the app instance rather than in `useDmsState`, which only carries
+ * serializable payload.
+ */
+export function useTrailingDeduper(name: string): TrailingDeduper {
+  const host = useDmsApp() as unknown as DeduperHost;
+  const key = `${DEDUPER_KEY_PREFIX}${name}`;
+  const existing = host[key] as TrailingDeduper | undefined;
+  if (existing) return existing;
+  const deduper = createTrailingDeduper();
+  host[key] = deduper;
+  return deduper;
+}

package/frontend-vue/layers/dms-core/app/composables/user/usePreferences.ts

@@ -0,0 +1,98 @@
+import { isObject } from "../../utils/type-check";
+
+export interface UserPreferences {
+  [key: string]: unknown;
+}
+
+const COOKIE_NAME = "user-preferences";
+const COOKIE_MAX_AGE_ONE_YEAR = 60 * 60 * 24 * 365;
+
+export const usePreferences = () => {
+  const preferenceCookie = useDmsCookie<UserPreferences>(COOKIE_NAME, {
+    default: () => ({}),
+    maxAge: COOKIE_MAX_AGE_ONE_YEAR,
+    sameSite: "lax",
+    secure: true,
+  });
+
+  const preferences = ref<UserPreferences>(preferenceCookie.value);
+
+  const getPreference = <T = unknown>(keyPath: string, defaultValue?: T): T => {
+    const keys = keyPath.split(".");
+    let current: unknown = preferences.value;
+
+    for (const key of keys) {
+      if (current && isObject(current) && key in current) {
+        current = (current as Record<string, unknown>)[key];
+      } else {
+        return defaultValue as T;
+      }
+    }
+
+    return current as T;
+  };
+
+  const setPreference = (keyPath: string, value: unknown): void => {
+    const keys = keyPath.split(".");
+    const lastKey = keys.pop()!;
+
+    let current = preferences.value;
+
+    for (const key of keys) {
+      if (!current[key] || !isObject(current[key])) {
+        current[key] = {};
+      }
+      current = current[key] as UserPreferences;
+    }
+
+    (current as Record<string, unknown>)[lastKey] = value;
+
+    preferenceCookie.value = preferences.value;
+  };
+
+  const removePreference = (keyPath: string): void => {
+    const keys = keyPath.split(".");
+    const lastKey = keys.pop()!;
+
+    let current = preferences.value;
+
+    for (const key of keys) {
+      if (!current[key] || !isObject(current[key])) {
+        return;
+      }
+      current = current[key] as UserPreferences;
+    }
+
+    if (lastKey in current) {
+      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+      delete (current as Record<string, unknown>)[lastKey];
+    }
+
+    preferenceCookie.value = preferences.value;
+  };
+
+  const updatePreference = <T = unknown>(
+    keyPath: string,
+    value: Partial<T>,
+  ): void => {
+    const current = getPreference<T>(keyPath, {} as T);
+    const merged = { ...current, ...value };
+    setPreference(keyPath, merged);
+  };
+
+  const clearAllPreferences = (): void => {
+    preferences.value = {};
+    preferenceCookie.value = {};
+  };
+
+  return {
+    preferences: readonly(computed(() => preferences.value)),
+
+    getPreference,
+    setPreference,
+    updatePreference,
+    removePreference,
+
+    clearAllPreferences,
+  };
+};

package/frontend-vue/layers/dms-core/app/composables/watch/useWatch.ts

@@ -0,0 +1,132 @@
+import { isUndefined } from "../../utils/type-check";
+import { ComponentId } from "../../types/watch";
+
+function getValueByPath(obj: unknown, path: string): unknown {
+  const keys = path.split(".");
+  let current: unknown = obj;
+  for (const key of keys) {
+    if (current === null || current === undefined) return undefined;
+    current = (current as Record<string, unknown>)[key];
+  }
+  return current;
+}
+
+function registerEventListeners(
+  eventNames: Set<string>,
+  handler: EventListener,
+) {
+  if (isUndefined(window)) return;
+  eventNames.forEach((eventName) => {
+    window.addEventListener(eventName, handler);
+  });
+}
+
+function unregisterEventListeners(
+  eventNames: Set<string>,
+  handler: EventListener,
+) {
+  if (isUndefined(window)) return;
+  eventNames.forEach((eventName) => {
+    window.removeEventListener(eventName, handler);
+  });
+}
+
+interface WatchEventDetail {
+  component?: string;
+  data?: unknown;
+}
+
+function checkParamConditions(
+  onParam: WatchAction["onParam"],
+  data: unknown,
+): boolean {
+  if (!onParam) return true;
+  const conditions = Array.isArray(onParam) ? onParam : [onParam];
+  for (const condition of conditions) {
+    const actualValue = getValueByPath(data, condition.key);
+    if (actualValue !== condition.value) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function isMatchingAction(
+  action: WatchAction,
+  event: CustomEvent,
+  detail: WatchEventDetail,
+  componentId?: string,
+): boolean {
+  const component =
+    action.component === ComponentId.SELF ? componentId : action.component;
+  if (component !== detail.component || action.event !== event.type) {
+    return false;
+  }
+  return checkParamConditions(action.onParam, detail.data);
+}
+
+export function useWatch(
+  actions: WatchAction[],
+  componentId?: string,
+  defaultState: Record<string, unknown> = {},
+) {
+  const isLoading = ref(false);
+  const componentState = ref<Record<string, unknown>>(defaultState);
+  const { getFunction } = useDefinedFunctions();
+
+  const requiredEvents = new Set<string>(actions.map((action) => action.event));
+
+  function runMatchingActions(
+    matchingActions: WatchAction[],
+    event: CustomEvent,
+  ) {
+    isLoading.value = true;
+    try {
+      for (const action of matchingActions) {
+        const actionFn = getFunction(action.functionId) as
+          | WatchActionFunction
+          | undefined;
+        if (!actionFn) {
+          continue;
+        }
+        try {
+          actionFn(action, event.detail, componentState);
+        } catch {
+          /* ignore — a single watch action failure must not break the loop */
+        }
+      }
+    } finally {
+      isLoading.value = false;
+    }
+  }
+
+  function handleWatchEvent(event: CustomEvent) {
+    const { detail } = event;
+    if (!detail) {
+      return;
+    }
+
+    const matchingActions = actions.filter((action) =>
+      isMatchingAction(action, event, detail, componentId),
+    );
+
+    if (matchingActions.length <= 0) {
+      return;
+    }
+
+    runMatchingActions(matchingActions, event);
+  }
+
+  onMounted(() => {
+    registerEventListeners(requiredEvents, handleWatchEvent as EventListener);
+  });
+
+  onUnmounted(() => {
+    unregisterEventListeners(requiredEvents, handleWatchEvent as EventListener);
+  });
+
+  return {
+    isLoading,
+    state: componentState,
+  };
+}

package/frontend-vue/layers/dms-core/app/types/auth-types.ts

@@ -0,0 +1,2 @@
+export * from "./user";
+export * from "./auth";

package/frontend-vue/layers/dms-core/app/types/auth.ts

@@ -0,0 +1,31 @@
+import type { User } from "./user";
+
+export interface TwoFactorRequiredResponse {
+  requires_2fa: true;
+  two_factor_token: string;
+  methods: string[];
+}
+
+export interface TenantAssignmentRequiredResponse {
+  requires_tenant_assignment: true;
+  tenant_assignment_token: string;
+  user: User;
+}
+
+export interface StoredAccount {
+  accountId: string;
+  userId: string;
+  email: string;
+  name: string;
+  lastUsed: Date;
+  isExpired?: boolean;
+}
+
+export interface ValidateAccountResponse {
+  valid: boolean | null;
+}
+
+export interface SwitchAccountResponse {
+  success: boolean;
+  user: User;
+}

package/frontend-vue/layers/dms-core/app/types/button.ts

@@ -0,0 +1,7 @@
+export enum ButtonVariant {
+  solid = "solid",
+  outline = "outline",
+  soft = "soft",
+  ghost = "ghost",
+  link = "link",
+}

package/frontend-vue/layers/dms-core/app/types/color.ts

@@ -0,0 +1,11 @@
+export enum Color {
+  primary = "primary",
+  secondary = "secondary",
+  success = "success",
+  info = "info",
+  warning = "warning",
+  error = "error",
+  neutral = "neutral",
+}
+
+export type ColorValue = `${Color}`;

package/frontend-vue/layers/dms-core/app/types/component.ts

@@ -0,0 +1,23 @@
+import type { WatchAction } from "./watch";
+import type { JsonValue } from "./json";
+
+export interface ComponentOptionsData {
+  [key: string]: JsonValue;
+}
+export interface DefaultComponentProps {
+  componentId: string;
+  pageId: string;
+  routeParams?: Record<string, string>;
+  watchActions?: WatchAction[];
+  childCount?: number;
+}
+
+export interface ComponentEventData {
+  component: string;
+  data?: unknown;
+}
+
+export const Events = {
+  LOAD: "DmsComponent.Load",
+  UNLOAD: "DmsComponent.Unload",
+} as const;

package/frontend-vue/layers/dms-core/app/types/data-type.ts

@@ -0,0 +1,11 @@
+export type ComponentOrNoInput =
+  | ComponentInfo<ComponentOptionsData>
+  | "noInput";
+
+export interface DataTypeConfig {
+  id: string;
+  compareModes: string[];
+  defaultCompareMode?: string;
+  filterComponents: Record<string, ComponentOrNoInput>;
+  inputComponent: ComponentInfo<ComponentOptionsData>;
+}

package/frontend-vue/layers/dms-core/app/types/http.ts

@@ -0,0 +1,18 @@
+export enum HttpMethod {
+  get = "GET",
+  post = "POST",
+  put = "PUT",
+  delete = "DELETE",
+  patch = "PATCH",
+  head = "HEAD",
+  options = "OPTIONS",
+}
+
+export interface QueryParams {
+  [key: string]: string | number | boolean | string[] | number[];
+}
+
+export interface EventError {
+  data?: string;
+  message?: string;
+}

package/frontend-vue/layers/dms-core/app/types/image.ts

@@ -0,0 +1,5 @@
+export interface ImageItemValue {
+  key: string;
+  alt?: string;
+  principal?: boolean;
+}

package/frontend-vue/layers/dms-core/app/types/json.ts

@@ -0,0 +1,6 @@
+export type JsonPrimitive = string | number | boolean | null;
+
+export type JsonValue =
+  | JsonPrimitive
+  | JsonValue[]
+  | { [key: string]: JsonValue };

package/frontend-vue/layers/dms-core/app/types/menu.ts

@@ -0,0 +1,36 @@
+import type { NavigationMenuItem } from "@nuxt/ui";
+
+/** Semantic look of a menu entry, mirroring `MenuItemVariant` in the backend. */
+export type MenuItemVariant = "default" | "accent";
+
+/** Semantic state dot of a menu entry, mirroring `MenuItemStatus` in the backend. */
+export type MenuItemStatus = "success" | "warning" | "error" | "neutral";
+
+/** Query parameters carried by a menu entry's link. */
+export type MenuItemQuery = Record<string, string>;
+
+/**
+ * A menu entry link. Entries carrying query parameters (one page serving many
+ * entries, e.g. `/project?project=<id>`) use the object form.
+ */
+export interface MenuItemTarget {
+  path: string;
+  query?: MenuItemQuery;
+}
+
+/**
+ * Nuxt UI menu item enriched with the DMS registration fields: the registered
+ * `fullId`, plus the semantic `variant` / `status` a page or a dynamic menu
+ * provider declares. Nuxt UI forwards unknown keys untouched.
+ */
+export interface DmsMenuItem extends NavigationMenuItem {
+  fullId?: string;
+  variant?: MenuItemVariant;
+  status?: MenuItemStatus;
+}
+
+/** The route a menu is highlighted against. */
+export interface MenuRouteState {
+  path: string;
+  query: Record<string, unknown>;
+}

package/frontend-vue/layers/dms-core/app/types/orientation.ts

@@ -0,0 +1,4 @@
+export enum AxeOrientation {
+  horizontal = "horizontal",
+  vertical = "vertical",
+}

package/frontend-vue/layers/dms-core/app/types/row-action-operators.ts

@@ -0,0 +1,60 @@
+type FieldComparatorSingle = <T>(fieldValue: T, ruleValue: T) => boolean;
+type FieldComparatorArray = <T>(fieldValue: T, ruleValue: T[]) => boolean;
+
+interface FieldOperatorDefSingle {
+  isArray: false;
+  compare: FieldComparatorSingle;
+}
+
+interface FieldOperatorDefArray {
+  isArray: true;
+  compare: FieldComparatorArray;
+}
+
+type FieldOperatorDef = FieldOperatorDefSingle | FieldOperatorDefArray;
+
+export const FIELD_OPERATORS = {
+  equals: {
+    isArray: false,
+    compare: <T>(fieldValue: T, ruleValue: T) => fieldValue === ruleValue,
+  },
+  notEquals: {
+    isArray: false,
+    compare: <T>(fieldValue: T, ruleValue: T) => fieldValue !== ruleValue,
+  },
+  in: {
+    isArray: true,
+    compare: <T>(fieldValue: T, ruleValue: T[]) =>
+      ruleValue.includes(fieldValue),
+  },
+  notIn: {
+    isArray: true,
+    compare: <T>(fieldValue: T, ruleValue: T[]) =>
+      !ruleValue.includes(fieldValue),
+  },
+} as const satisfies Record<string, FieldOperatorDef>;
+
+export const FIELD_KEY = "field" as const;
+
+export type FieldOperatorKey = keyof typeof FIELD_OPERATORS;
+
+type IsArrayOperator<Op extends FieldOperatorKey> =
+  (typeof FIELD_OPERATORS)[Op]["isArray"];
+
+export type FieldRule<
+  T extends Record<string, unknown>,
+  Op extends FieldOperatorKey,
+> = {
+  [K in keyof T]: { field: K } & Record<
+    Op,
+    IsArrayOperator<Op> extends true ? T[K][] : T[K]
+  >;
+}[keyof T];
+
+export type AnyFieldRule<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = {
+  [Op in FieldOperatorKey]: FieldRule<T, Op>;
+}[FieldOperatorKey];
+
+export const LOGICAL_OPERATOR_KEYS = ["and", "or", "not"] as const;

package/frontend-vue/layers/dms-core/app/types/row-action.ts

@@ -0,0 +1,51 @@
+import type { AnyFieldRule, FieldRule } from "./row-action-operators";
+
+export type FieldEqualsRule<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = FieldRule<T, "equals">;
+
+export type FieldNotEqualsRule<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = FieldRule<T, "notEquals">;
+
+export type FieldInRule<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = FieldRule<T, "in">;
+
+export type FieldNotInRule<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = FieldRule<T, "notIn">;
+
+export type AndRule<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = {
+  and: RowActionRule<T>[];
+};
+
+export type OrRule<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = {
+  or: RowActionRule<T>[];
+};
+
+export type NotRule<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = {
+  not: RowActionRule<T>;
+};
+
+export type LogicalRule<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = AndRule<T> | OrRule<T> | NotRule<T>;
+
+export type RowActionRule<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> = AnyFieldRule<T> | LogicalRule<T>;
+
+export interface RowActionConfig<
+  T extends Record<string, unknown> = Record<string, unknown>,
+> {
+  isEnabled?: boolean;
+  isVisible?: boolean;
+  rule?: RowActionRule<T>;
+}

package/frontend-vue/layers/dms-core/app/types/size.ts

@@ -0,0 +1,7 @@
+export enum Size {
+  tiny = "xs",
+  small = "sm",
+  medium = "md",
+  large = "lg",
+  huge = "xl",
+}

package/frontend-vue/layers/dms-core/app/types/user.ts

@@ -0,0 +1,9 @@
+export interface User {
+  _id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  email: string;
+  name: string;
+  language: string;
+  isValidated: boolean;
+}

package/frontend-vue/layers/dms-core/app/types/utils.ts

@@ -0,0 +1 @@
+export type MaybePromise<T> = T | Promise<T>;

package/frontend-vue/layers/dms-core/app/types/watch.ts

@@ -0,0 +1,25 @@
+import type { Ref } from "vue";
+import type { ComponentEventData } from "./component";
+
+export const ComponentId = {
+  SELF: "$component:self",
+} as const;
+
+export type WatchActionFunction = (
+  action: WatchAction,
+  eventData: ComponentEventData,
+  componentState: Ref<Record<string, unknown>>,
+) => void;
+
+export interface WatchActionCondition {
+  key: string;
+  value: unknown;
+}
+
+export interface WatchAction {
+  component: string;
+  event: string;
+  functionId: string;
+  params?: Record<string, unknown>;
+  onParam?: WatchActionCondition | WatchActionCondition[];
+}

package/frontend-vue/layers/dms-core/app/utils/dedupedRefresh.ts

@@ -0,0 +1,33 @@
+/**
+ * Run an async task at most once concurrently against a shared holder object.
+ *
+ * Concurrent callers receive the exact same in-flight promise; once it settles
+ * the slot is cleared so the next call starts a fresh run. Used to coalesce
+ * parallel session refreshes (the realtime stream, $authFetch and route
+ * middleware can all hit a 401 at the same moment) into a single
+ * /api/auth/refresh call, so competing refreshes never rotate the refresh
+ * token out from under each other and log the user out.
+ */
+export function runDeduped<T>(
+  holder: Record<PropertyKey, unknown>,
+  key: PropertyKey,
+  task: () => Promise<T>,
+): Promise<T> {
+  const existing = holder[key] as Promise<T> | null | undefined;
+  if (existing) {
+    return existing;
+  }
+
+  let started: Promise<T>;
+  try {
+    started = task();
+  } catch (error) {
+    started = Promise.reject(error);
+  }
+
+  const promise = started.finally(() => {
+    holder[key] = null;
+  });
+  holder[key] = promise;
+  return promise;
+}

package/frontend-vue/layers/dms-core/app/utils/downloadFile.ts

@@ -0,0 +1,8 @@
+export function downloadFile(url: string, filename: string) {
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+}