create-windy 0.1.0

package/template/apps/web/src/components/ui/tabs/TabsTrigger.vue

@@ -0,0 +1,33 @@
+<script setup lang="ts">
+import type { TabsTriggerProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { TabsTrigger, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/utils";
+
+const props = defineProps<
+  TabsTriggerProps & { class?: HTMLAttributes["class"] }
+>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <TabsTrigger
+    data-slot="tabs-trigger"
+    :class="
+      cn(
+        'gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg:not([class*=size-])]:size-4 has-data-[icon=inline-end]:pr-1 has-data-[icon=inline-start]:pl-1 relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center whitespace-nowrap text-foreground/60 transition-all group-data-vertical/tabs:w-full group-data-vertical/tabs:justify-start hover:text-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring disabled:pointer-events-none disabled:opacity-50 dark:text-muted-foreground dark:hover:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        'group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent',
+        'data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground',
+        'after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-horizontal/tabs:after:inset-x-0 group-data-horizontal/tabs:after:bottom-[-5px] group-data-horizontal/tabs:after:h-0.5 group-data-vertical/tabs:after:inset-y-0 group-data-vertical/tabs:after:-right-1 group-data-vertical/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100',
+        props.class,
+      )
+    "
+    v-bind="forwardedProps"
+  >
+    <slot />
+  </TabsTrigger>
+</template>

package/template/apps/web/src/components/ui/tabs/index.ts

@@ -0,0 +1,24 @@
+import type { VariantProps } from "class-variance-authority";
+import { cva } from "class-variance-authority";
+
+export { default as Tabs } from "./Tabs.vue";
+export { default as TabsContent } from "./TabsContent.vue";
+export { default as TabsList } from "./TabsList.vue";
+export { default as TabsTrigger } from "./TabsTrigger.vue";
+
+export const tabsListVariants = cva(
+  "rounded-lg p-0.75 group-data-horizontal/tabs:h-8 data-[variant=line]:rounded-none group/tabs-list inline-flex w-fit items-center justify-center text-muted-foreground group-data-vertical/tabs:h-fit group-data-vertical/tabs:flex-col",
+  {
+    variants: {
+      variant: {
+        default: "bg-muted",
+        line: "gap-1 bg-transparent",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  },
+);
+
+export type TabsListVariants = VariantProps<typeof tabsListVariants>;

package/template/apps/web/src/components/ui/tooltip/Tooltip.vue

@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { TooltipRootEmits, TooltipRootProps } from "reka-ui";
+import { TooltipRoot, useForwardPropsEmits } from "reka-ui";
+
+const props = defineProps<TooltipRootProps>();
+const emits = defineEmits<TooltipRootEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <TooltipRoot v-slot="slotProps" data-slot="tooltip" v-bind="forwarded">
+    <slot v-bind="slotProps" />
+  </TooltipRoot>
+</template>

package/template/apps/web/src/components/ui/tooltip/TooltipContent.vue

@@ -0,0 +1,49 @@
+<script setup lang="ts">
+import type { TooltipContentEmits, TooltipContentProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import {
+  TooltipArrow,
+  TooltipContent,
+  TooltipPortal,
+  useForwardPropsEmits,
+} from "reka-ui";
+import { cn } from "@/lib/utils";
+
+defineOptions({
+  inheritAttrs: false,
+});
+
+const props = withDefaults(
+  defineProps<TooltipContentProps & { class?: HTMLAttributes["class"] }>(),
+  {
+    sideOffset: 0,
+  },
+);
+
+const emits = defineEmits<TooltipContentEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <TooltipPortal>
+    <TooltipContent
+      data-slot="tooltip-content"
+      v-bind="{ ...forwarded, ...$attrs }"
+      :class="
+        cn(
+          'data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-[state=delayed-open]:animate-in data-[state=delayed-open]:fade-in-0 data-[state=delayed-open]:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 inline-flex items-center gap-1.5 rounded-md px-3 py-1.5 text-xs has-data-[slot=kbd]:pr-1.5 **:data-[slot=kbd]:relative **:data-[slot=kbd]:isolate **:data-[slot=kbd]:z-50 **:data-[slot=kbd]:rounded-sm bg-foreground text-background z-50 w-fit max-w-xs origin-(--reka-tooltip-content-transform-origin)',
+          props.class,
+        )
+      "
+    >
+      <slot />
+
+      <TooltipArrow
+        class="size-2.5 rotate-45 rounded-xs bg-foreground fill-foreground z-50 translate-y-[calc(-50%_-_2px)]"
+      />
+    </TooltipContent>
+  </TooltipPortal>
+</template>

package/template/apps/web/src/components/ui/tooltip/TooltipProvider.vue

@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import type { TooltipProviderProps } from "reka-ui";
+import { TooltipProvider } from "reka-ui";
+
+const props = withDefaults(defineProps<TooltipProviderProps>(), {
+  delayDuration: 0,
+});
+</script>
+
+<template>
+  <TooltipProvider v-bind="props">
+    <slot />
+  </TooltipProvider>
+</template>

package/template/apps/web/src/components/ui/tooltip/TooltipTrigger.vue

@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { TooltipTriggerProps } from "reka-ui";
+import { TooltipTrigger } from "reka-ui";
+
+const props = defineProps<TooltipTriggerProps>();
+</script>
+
+<template>
+  <TooltipTrigger data-slot="tooltip-trigger" v-bind="props">
+    <slot />
+  </TooltipTrigger>
+</template>

package/template/apps/web/src/components/ui/tooltip/index.ts

@@ -0,0 +1,4 @@
+export { default as Tooltip } from "./Tooltip.vue";
+export { default as TooltipContent } from "./TooltipContent.vue";
+export { default as TooltipProvider } from "./TooltipProvider.vue";
+export { default as TooltipTrigger } from "./TooltipTrigger.vue";

package/template/apps/web/src/composables/useAccessSnapshot.ts

@@ -0,0 +1,55 @@
+import { readonly, shallowReadonly, shallowRef } from "vue";
+import type { WebAccessSnapshot } from "@/layout/navigation";
+import { loadAccessSnapshot } from "@/services/access-api";
+
+const snapshot = shallowRef<WebAccessSnapshot>();
+const loading = shallowRef(false);
+const error = shallowRef("");
+let pending: Promise<WebAccessSnapshot> | undefined;
+let generation = 0;
+
+async function load(force = false): Promise<WebAccessSnapshot> {
+  if (pending) return pending;
+  if (snapshot.value && !force) return snapshot.value;
+  loading.value = true;
+  error.value = "";
+  const requestGeneration = generation;
+  const operation = loadAccessSnapshot()
+    .then((result) => {
+      if (requestGeneration === generation) snapshot.value = result;
+      return result;
+    })
+    .catch((currentError: unknown) => {
+      if (requestGeneration === generation) {
+        error.value =
+          currentError instanceof Error
+            ? currentError.message
+            : String(currentError);
+      }
+      throw currentError;
+    })
+    .finally(() => {
+      if (requestGeneration === generation) loading.value = false;
+      if (pending === operation) pending = undefined;
+    });
+  pending = operation;
+  return operation;
+}
+
+export function resetAccessSnapshot(): void {
+  generation += 1;
+  snapshot.value = undefined;
+  loading.value = false;
+  error.value = "";
+  pending = undefined;
+}
+
+export function useAccessSnapshot() {
+  return {
+    snapshot: shallowReadonly(snapshot),
+    loading: readonly(loading),
+    error: readonly(error),
+    ensureLoaded: () => load(false),
+    refresh: () => load(true),
+  };
+}

package/template/apps/web/src/composables/useAccessSnapshot.webtest.ts

@@ -0,0 +1,39 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ loadAccessSnapshot: vi.fn() }));
+vi.mock("@/services/access-api", () => mocks);
+
+import { resetAccessSnapshot, useAccessSnapshot } from "./useAccessSnapshot";
+
+describe("权限快照 single-flight", () => {
+  beforeEach(() => {
+    resetAccessSnapshot();
+    mocks.loadAccessSnapshot.mockReset();
+  });
+
+  test("并发导航刷新只发起一个 foundation 请求", async () => {
+    const snapshot = {
+      actor: {
+        id: "user_1",
+        type: "user" as const,
+        name: "测试员",
+        roleCodes: ["member"],
+        permissionKeys: [],
+      },
+      menus: [],
+      permissions: [],
+      features: [],
+    };
+    mocks.loadAccessSnapshot.mockResolvedValue(snapshot);
+    const access = useAccessSnapshot();
+
+    const [first, second] = await Promise.all([
+      access.ensureLoaded(),
+      access.refresh(),
+    ]);
+
+    expect(mocks.loadAccessSnapshot).toHaveBeenCalledTimes(1);
+    expect(first).toEqual(snapshot);
+    expect(second).toEqual(snapshot);
+  });
+});

package/template/apps/web/src/composables/useAppToast.ts

@@ -0,0 +1,30 @@
+import type { ExternalToast } from "vue-sonner";
+import { toast } from "vue-sonner";
+
+type ToastOptions = ExternalToast;
+
+export function useAppToast() {
+  function success(message = "操作成功", options?: ToastOptions) {
+    return toast.success(message, options);
+  }
+
+  function error(message = "操作失败，请稍后重试", options?: ToastOptions) {
+    return toast.error(message, options);
+  }
+
+  function info(message = "已收到请求", options?: ToastOptions) {
+    return toast.info(message, options);
+  }
+
+  function loading(message = "正在处理，请稍候", options?: ToastOptions) {
+    return toast.loading(message, options);
+  }
+
+  return {
+    success,
+    error,
+    info,
+    loading,
+    dismiss: toast.dismiss,
+  };
+}

package/template/apps/web/src/composables/useAuthSession.ts

@@ -0,0 +1,127 @@
+import { computed, readonly, shallowReadonly, shallowRef } from "vue";
+import type { WebAccessActor } from "@/layout/navigation";
+import type { LoginCredentials } from "@/services/auth-api";
+import {
+  loadCurrentSession,
+  loginWithPassword,
+  logoutCurrentSession,
+} from "@/services/auth-api";
+import { isApiErrorStatus, suspendDevelopmentAuth } from "@/services/http";
+
+export type AuthPhase =
+  | "unknown"
+  | "checking"
+  | "authenticated"
+  | "anonymous"
+  | "error";
+
+export interface AuthSessionSnapshot {
+  phase: AuthPhase;
+  actor?: WebAccessActor;
+}
+
+const phase = shallowRef<AuthPhase>("unknown");
+const actor = shallowRef<WebAccessActor>();
+const error = shallowRef("");
+let pending: Promise<AuthSessionSnapshot> | undefined;
+let generation = 0;
+
+async function refresh(force = false): Promise<AuthSessionSnapshot> {
+  if (pending) return pending;
+  if (!force && phase.value !== "unknown" && phase.value !== "error") {
+    return currentSnapshot();
+  }
+  phase.value = "checking";
+  error.value = "";
+  const requestGeneration = generation;
+  const operation = loadCurrentSession()
+    .then((currentActor) => {
+      if (requestGeneration === generation) {
+        actor.value = currentActor;
+        phase.value = "authenticated";
+      }
+      return currentSnapshot();
+    })
+    .catch((current: unknown) => {
+      if (requestGeneration !== generation) return currentSnapshot();
+      actor.value = undefined;
+      if (isApiErrorStatus(current, 401)) {
+        phase.value = "anonymous";
+        return currentSnapshot();
+      }
+      phase.value = "error";
+      error.value = messageOf(current);
+      throw current;
+    })
+    .finally(() => {
+      if (pending === operation) pending = undefined;
+    });
+  pending = operation;
+  return operation;
+}
+
+async function login(
+  credentials: LoginCredentials,
+): Promise<AuthSessionSnapshot> {
+  error.value = "";
+  try {
+    await loginWithPassword(credentials);
+    suspendDevelopmentAuth();
+    phase.value = "unknown";
+    return await refresh(true);
+  } catch (current) {
+    if (isApiErrorStatus(current, 401)) phase.value = "anonymous";
+    error.value = messageOf(current);
+    throw current;
+  }
+}
+
+async function logout(): Promise<void> {
+  error.value = "";
+  try {
+    await logoutCurrentSession();
+    clearAuthSession();
+  } catch (current) {
+    if (isApiErrorStatus(current, 401)) clearAuthSession();
+    else error.value = messageOf(current);
+    throw current;
+  }
+}
+
+function currentSnapshot(): AuthSessionSnapshot {
+  return { phase: phase.value, actor: actor.value };
+}
+
+export function clearAuthSession(): void {
+  generation += 1;
+  actor.value = undefined;
+  phase.value = "anonymous";
+  error.value = "";
+}
+
+export function resetAuthSession(): void {
+  generation += 1;
+  actor.value = undefined;
+  phase.value = "unknown";
+  error.value = "";
+  pending = undefined;
+}
+
+export function useAuthSession() {
+  return {
+    phase: readonly(phase),
+    actor: shallowReadonly(actor),
+    error: readonly(error),
+    authenticated: computed(() => phase.value === "authenticated"),
+    checking: computed(() => phase.value === "checking"),
+    ensureInitialized: () => refresh(false),
+    refresh: () => refresh(true),
+    clear: clearAuthSession,
+    login,
+    logout,
+  };
+}
+
+function messageOf(value: unknown): string {
+  return value instanceof Error ? value.message : String(value);
+}

package/template/apps/web/src/composables/useAuthSession.webtest.ts

@@ -0,0 +1,48 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  loadCurrentSession: vi.fn(),
+  loginWithPassword: vi.fn(),
+  logoutCurrentSession: vi.fn(),
+}));
+
+vi.mock("@/services/auth-api", () => mocks);
+
+import { resetAuthSession, useAuthSession } from "./useAuthSession";
+
+describe("认证状态 single-flight", () => {
+  beforeEach(() => {
+    resetAuthSession();
+    mocks.loadCurrentSession.mockReset();
+  });
+
+  test("并发启动探测复用同一个请求", async () => {
+    mocks.loadCurrentSession.mockResolvedValue({
+      id: "user_1",
+      type: "user",
+      name: "测试员",
+      roleCodes: ["member"],
+      permissionKeys: [],
+    });
+    const auth = useAuthSession();
+
+    const [first, second] = await Promise.all([
+      auth.ensureInitialized(),
+      auth.refresh(),
+    ]);
+
+    expect(mocks.loadCurrentSession).toHaveBeenCalledTimes(1);
+    expect(first.phase).toBe("authenticated");
+    expect(second.actor?.id).toBe("user_1");
+  });
+
+  test("非 401 故障保留 error 状态而不是伪装成匿名", async () => {
+    mocks.loadCurrentSession.mockRejectedValue(new Error("network down"));
+    const auth = useAuthSession();
+
+    await expect(auth.ensureInitialized()).rejects.toThrow("network down");
+
+    expect(auth.phase.value).toBe("error");
+    expect(auth.authenticated.value).toBe(false);
+  });
+});

package/template/apps/web/src/composables/useLicenseReminderRefresh.ts

@@ -0,0 +1,27 @@
+import { onMounted, onUnmounted } from "vue";
+
+const DEFAULT_REFRESH_INTERVAL_MS = 60 * 1000;
+
+export function useLicenseReminderRefresh(
+  refresh: () => Promise<unknown>,
+  intervalMs = DEFAULT_REFRESH_INTERVAL_MS,
+): void {
+  let timer: ReturnType<typeof setInterval> | undefined;
+  let refreshing = false;
+
+  onMounted(() => {
+    timer = setInterval(() => {
+      if (refreshing) return;
+      refreshing = true;
+      void refresh()
+        .catch(() => undefined)
+        .finally(() => {
+          refreshing = false;
+        });
+    }, intervalMs);
+  });
+
+  onUnmounted(() => {
+    if (timer !== undefined) clearInterval(timer);
+  });
+}

package/template/apps/web/src/composables/useLicenseReminderRefresh.webtest.ts

@@ -0,0 +1,30 @@
+import { mount } from "@vue/test-utils";
+import { defineComponent } from "vue";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { useLicenseReminderRefresh } from "./useLicenseReminderRefresh";
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+describe("License 提醒自动刷新", () => {
+  test("长时间停留会刷新本机状态，组件卸载后停止", async () => {
+    vi.useFakeTimers();
+    const refresh = vi.fn(async () => undefined);
+    const wrapper = mount(
+      defineComponent({
+        setup() {
+          useLicenseReminderRefresh(refresh, 1000);
+          return () => null;
+        },
+      }),
+    );
+
+    await vi.advanceTimersByTimeAsync(3000);
+    expect(refresh).toHaveBeenCalledTimes(3);
+
+    wrapper.unmount();
+    await vi.advanceTimersByTimeAsync(2000);
+    expect(refresh).toHaveBeenCalledTimes(3);
+  });
+});

package/template/apps/web/src/composables/useLicenseRuntime.ts

@@ -0,0 +1,90 @@
+import { readonly, shallowReadonly, shallowRef } from "vue";
+import {
+  installPlatformActivationCode,
+  installPlatformLicense,
+  loadPlatformLicense,
+  type PlatformLicenseSnapshot,
+} from "@/services/license-api";
+
+const snapshot = shallowRef<PlatformLicenseSnapshot>();
+const loading = shallowRef(false);
+const installing = shallowRef(false);
+const error = shallowRef("");
+let pending: Promise<PlatformLicenseSnapshot> | undefined;
+let generation = 0;
+
+async function load(force = false): Promise<PlatformLicenseSnapshot> {
+  if (pending) return pending;
+  if (snapshot.value && !force) return snapshot.value;
+  loading.value = true;
+  error.value = "";
+  const requestGeneration = generation;
+  const operation = loadPlatformLicense()
+    .then((value) => {
+      if (requestGeneration === generation) snapshot.value = value;
+      return value;
+    })
+    .catch((current: unknown) => {
+      if (requestGeneration === generation) error.value = messageOf(current);
+      throw current;
+    })
+    .finally(() => {
+      if (requestGeneration === generation) loading.value = false;
+      if (pending === operation) pending = undefined;
+    });
+  pending = operation;
+  return operation;
+}
+
+export function resetLicenseRuntime(): void {
+  generation += 1;
+  snapshot.value = undefined;
+  loading.value = false;
+  installing.value = false;
+  error.value = "";
+  pending = undefined;
+}
+
+async function install(rawLicense: string): Promise<PlatformLicenseSnapshot> {
+  return performInstall(() => installPlatformLicense(rawLicense));
+}
+
+async function installActivationCode(
+  activationCode: string,
+): Promise<PlatformLicenseSnapshot> {
+  return performInstall(() => installPlatformActivationCode(activationCode));
+}
+
+async function performInstall(
+  operation: () => ReturnType<typeof installPlatformLicense>,
+): Promise<PlatformLicenseSnapshot> {
+  installing.value = true;
+  error.value = "";
+  try {
+    const result = await operation();
+    snapshot.value = result.snapshot;
+    return result.snapshot;
+  } catch (current) {
+    error.value = messageOf(current);
+    throw current;
+  } finally {
+    installing.value = false;
+  }
+}
+
+export function useLicenseRuntime() {
+  return {
+    snapshot: shallowReadonly(snapshot),
+    loading: readonly(loading),
+    installing: readonly(installing),
+    error: readonly(error),
+    ensureLoaded: () => load(false),
+    refresh: () => load(true),
+    install,
+    installActivationCode,
+  };
+}
+
+function messageOf(value: unknown): string {
+  return value instanceof Error ? value.message : String(value);
+}

package/template/apps/web/src/composables/useLoginFlow.ts

@@ -0,0 +1,39 @@
+import { computed, shallowRef } from "vue";
+import { useRoute, useRouter } from "vue-router";
+import { resetAccessSnapshot } from "@/composables/useAccessSnapshot";
+import { useAuthSession } from "@/composables/useAuthSession";
+// @windy-module system.license begin
+import { resetLicenseRuntime } from "@/composables/useLicenseRuntime";
+// @windy-module system.license end
+import { resetSessionContext } from "@/composables/useSessionContext";
+import { safeReturnTo } from "@/router/auth-navigation";
+import type { LoginCredentials } from "@/services/auth-api";
+
+export function useLoginFlow() {
+  const auth = useAuthSession();
+  const route = useRoute();
+  const router = useRouter();
+  const submitError = shallowRef("");
+  const loading = computed(() => auth.phase.value === "checking");
+
+  async function submit(credentials: LoginCredentials): Promise<void> {
+    submitError.value = "";
+    try {
+      await auth.login(credentials);
+      resetAccessSnapshot();
+      // @windy-module system.license begin
+      resetLicenseRuntime();
+      // @windy-module system.license end
+      resetSessionContext();
+      await router.replace(safeReturnTo(route.query.returnTo));
+    } catch {
+      submitError.value = auth.error.value || "登录失败，请稍后重试";
+    }
+  }
+
+  return {
+    loading,
+    submitError,
+    submit,
+  };
+}