@shwfed/nuxt 0.1.64 → 0.1.66

package/dist/runtime/components/app.vue.d.ts

@@ -1,81 +1,6 @@
 import type { Scope } from 'effect';
 import { Effect } from 'effect';
-type Item = Readonly<{
-    id: string;
-    /**
-     * 命令的标题
-     *
-     * 调用者处理 i18n
-     *
-     * @type string
-     */
-    title: string;
-    /**
-     * 命令的图标
-     *
-     * @type string
-     */
-    icon?: string;
-    /**
-     * 命令是否禁用
-     *
-     * @type DSL
-     */
-    disabled?: boolean | string;
-    /**
-     * 命令是否隐藏
-     *
-     * @type DSL | boolean
-     */
-    hidden?: boolean | string;
-    /**
-     * 命令的关键词
-     *
-     * @type string[]
-     */
-    keywords?: ReadonlyArray<string>;
-}>;
-type CommandPosition = 'profile' | 'command-palette';
-interface Command extends Item {
-    positions: ReadonlyArray<CommandPosition>;
-    effect: Effect.Effect<void, never, Scope.Scope>;
-}
-interface Navigation extends Item {
-    /**
-     * 导航项的跳转目标
-     *
-     * @type string
-     */
-    target: string;
-    /**
-     * 导航项是否为外部链接
-     *
-     * @type DSL
-     */
-    external: string;
-}
 type __VLS_Props = {
-    /**
-     * 所有导航项
-     */
-    navigation?: ReadonlyArray<Navigation | Readonly<{
-        id: string;
-        title: string;
-        icon?: string;
-        children: ReadonlyArray<Navigation>;
-    }>>;
-    /**
-     * 应用内命令列表，用于命令面板（Cmd+K）和/或顶栏个人资料下拉菜单。
-     * 每项为「单个命令」或「分组」：单个命令含 positions、effect；分组含 id、title、可选 icon、children（Command 数组）。
-     * positions 控制展示位置：'command-palette' 出现在命令面板，'profile' 出现在个人资料菜单；可同时包含两者。
-     * 用户选择某命令时执行其 effect（带 Scope）。可选 disabled、hidden（CEL 表达式）、keywords 与导航等用法一致。
-     */
-    commands?: ReadonlyArray<Command | Readonly<{
-        id: string;
-        title: string;
-        icon?: string;
-        children: ReadonlyArray<Command>;
-    }>>;
     /**
      * 应用的全局 DSL（CEL）执行上下文。传入一个 Effect，在应用启动时运行一次；
      * 其解析结果（一个 record）会被永久设为全局上下文，供后续所有 CEL 求值（如 `$dsl.evaluate`）使用。
@@ -114,11 +39,11 @@ type __VLS_Props = {
      */
     dsl?: Effect.Effect<Record<string, unknown>, never, Scope.Scope>;
 };
-declare var __VLS_103: {}, __VLS_377: {};
+declare var __VLS_122: {}, __VLS_346: {};
 type __VLS_Slots = {} & {
-    menu?: (props: typeof __VLS_103) => any;
+    menu?: (props: typeof __VLS_122) => any;
 } & {
-    default?: (props: typeof __VLS_377) => any;
+    default?: (props: typeof __VLS_346) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/runtime/components/ui/sidebar/SidebarGroup.vue

@@ -9,7 +9,7 @@ const props = defineProps({
   <div
     data-slot="sidebar-group"
     data-sidebar="group"
-    :class="cn('relative flex w-full min-w-0 flex-col p-2', props.class)"
+    :class="cn('relative flex w-full min-w-0 flex-col px-2', props.class)"
   >
     <slot />
   </div>

package/dist/runtime/components/ui/sidebar/SidebarGroupLabel.vue

@@ -15,7 +15,7 @@ const props = defineProps({
     :as="as"
     :as-child="asChild"
     :class="cn(
-  'text-zinc-700/70 flex h-8 shrink-0 items-center rounded-md px-2 text-xs font-medium outline-hidden transition-[margin,opacity] duration-200 ease-linear [&>svg]:size-4 [&>svg]:shrink-0',
+  'text-zinc-700/70 flex gap-x-2 h-8 shrink-0 items-center rounded-md px-2 text-xs font-medium outline-hidden transition-[margin,opacity] duration-200 ease-linear [&>svg]:size-4 [&>svg]:shrink-0',
   'group-data-[collapsible=icon]:-mt-8 group-data-[collapsible=icon]:opacity-0',
   props.class
 )"

package/dist/runtime/components/ui/sidebar/SidebarMenu.vue

@@ -9,7 +9,7 @@ const props = defineProps({
   <ul
     data-slot="sidebar-menu"
     data-sidebar="menu"
-    :class="cn('flex w-full min-w-0 flex-col gap-1', props.class)"
+    :class="cn('flex w-full min-w-0 flex-col gap-1 py-1', props.class)"
   >
     <slot />
   </ul>

package/dist/runtime/composables/useFavorite.d.ts

@@ -0,0 +1,23 @@
+import { type MaybeRefOrGetter } from 'vue';
+type Item<K extends string | number> = Readonly<{
+    id: K;
+}>;
+type Group<K extends string | number> = Readonly<{
+    id: K;
+    children: Array<Item<K>>;
+}>;
+type Favoritable<K extends string | number> = Item<K> | Group<K>;
+export declare function useFavorite<K extends string | number, T extends Favoritable<K>>(key: string, items: MaybeRefOrGetter<Array<T>>): {
+    favorite: <I extends Item<K>>(item: I, of: K) => void;
+    unfavorite: <I extends Item<K>>(item: I, of?: K) => void;
+    toggle: <I extends Item<K>>(item: I, of: K) => void;
+    isFavorited: (item: Item<K>, of: K) => boolean;
+    canBeFavorited: (_: Item<K>, of: K) => boolean;
+    withFavorites: import("vue").ComputedRef<(T | {
+        id: string;
+        title: string;
+        icon: string;
+        children: T[];
+    })[]>;
+};
+export {};

package/dist/runtime/composables/useFavorite.js

@@ -0,0 +1,68 @@
+import { useLocalStorage } from "@vueuse/core";
+import { computed, toValue } from "vue";
+import { useI18n } from "vue-i18n";
+const isItem = (item) => !("children" in item);
+const isGroup = (item) => "children" in item;
+export function useFavorite(key, items) {
+  const { t } = useI18n({
+    useScope: "global",
+    messages: {
+      zh: { favorites: "\u6536\u85CF" },
+      ja: { favorites: "\u304A\u6C17\u306B\u5165\u308A" },
+      en: { favorites: "Favorites" }
+    }
+  });
+  const memo = useLocalStorage(`favorite-${key}`, /* @__PURE__ */ new Set(), {
+    writeDefaults: false
+  });
+  const keyed = (item, of) => [item.id, of].filter((v) => v !== void 0).join("::");
+  const unkeyed = (key2) => {
+    const [id, of] = key2.split("::");
+    return [id, of];
+  };
+  return {
+    favorite: (item, of) => {
+      memo.value = new Set(memo.value).add(keyed(item, of));
+    },
+    unfavorite: (item, of) => {
+      const next = new Set(memo.value);
+      next.delete(keyed(item, of));
+      memo.value = next;
+    },
+    toggle: (item, of) => {
+      const next = new Set(memo.value);
+      const key2 = keyed(item, of);
+      if (next.has(key2)) {
+        next.delete(key2);
+      } else {
+        next.add(key2);
+      }
+      memo.value = next;
+    },
+    isFavorited: (item, of) => {
+      return memo.value.has(keyed(item, of));
+    },
+    canBeFavorited: (_, of) => {
+      return of !== "$favorites";
+    },
+    withFavorites: computed(() => {
+      return [
+        {
+          id: "$favorites",
+          title: t("favorites"),
+          icon: "fluent:star-20-regular",
+          children: Array.from(memo.value.values()).map((key2) => {
+            const [id, of] = unkeyed(key2);
+            if (of === void 0) {
+              return toValue(items).find((item) => isItem(item) && item.id === id);
+            } else {
+              const group = toValue(items).find((item) => isGroup(item) && item.id === of);
+              return group?.children?.find((item) => item.id === id);
+            }
+          }).filter(Boolean)
+        },
+        ...toValue(items)
+      ].filter((group) => "children" in group ? group.children.length > 0 : true);
+    })
+  };
+}

package/dist/runtime/composables/useNavigationTabs.d.ts

@@ -0,0 +1,7 @@
+export declare function useNavigationTabs(): {
+    tabs: import("@vueuse/shared").RemovableRef<Set<string>>;
+    tabList: import("vue").ComputedRef<string[]>;
+    active: import("@vueuse/shared").RemovableRef<string | undefined>;
+    activateTab: (tab: string) => void;
+    closeTab: (tab: string) => void;
+};

package/dist/runtime/composables/useNavigationTabs.js

@@ -0,0 +1,65 @@
+import { useRoute, useRouter } from "#app";
+import { useSessionStorage } from "@vueuse/core";
+import { computed, watch } from "vue";
+import { normalizeRoutePath } from "../utils/route.js";
+export function useNavigationTabs() {
+  const tabs = useSessionStorage("navigation-tabs", /* @__PURE__ */ new Set(), {
+    writeDefaults: false
+  });
+  const active = useSessionStorage("navigation-active-tab", void 0, {
+    writeDefaults: false
+  });
+  const route = useRoute();
+  const router = useRouter();
+  const tabList = computed(() => Array.from(tabs.value));
+  const activateTab = (tab) => {
+    active.value = normalizeRoutePath(tab);
+  };
+  const closeTab = (tab) => {
+    const normalizedTab = normalizeRoutePath(tab);
+    const nextTabs = tabList.value;
+    const closedIndex = nextTabs.findIndex((tab2) => tab2 === normalizedTab);
+    tabs.value.delete(normalizedTab);
+    if (active.value !== normalizedTab)
+      return;
+    const previousTab = closedIndex > 0 ? nextTabs[closedIndex - 1] : void 0;
+    const nextTab = closedIndex >= 0 ? nextTabs[closedIndex + 1] : void 0;
+    const fallbackTab = previousTab ?? nextTab;
+    if (fallbackTab) {
+      activateTab(fallbackTab);
+      return;
+    }
+    activateTab("/");
+  };
+  watch(active, (tab) => {
+    if (!tab)
+      return;
+    const normalizedTab = normalizeRoutePath(tab);
+    if (tab !== normalizedTab) {
+      active.value = normalizedTab;
+      return;
+    }
+    if (route.path !== normalizedTab)
+      router.replace(normalizedTab);
+    if (!tabs.value.has(normalizedTab))
+      tabs.value.add(normalizedTab);
+  });
+  watch(
+    () => route.path,
+    (path) => {
+      const normalizedPath = normalizeRoutePath(path);
+      if (active.value !== normalizedPath)
+        active.value = normalizedPath;
+      if (!tabs.value.has(normalizedPath))
+        tabs.value.add(normalizedPath);
+    },
+    { immediate: true }
+  );
+  return {
+    tabs,
+    tabList,
+    active,
+    activateTab,
+    closeTab
+  };
+}

package/dist/runtime/plugins/api/index.js

@@ -1,5 +1,6 @@
 import { defineNuxtPlugin, navigateTo, useNuxtApp, useRuntimeConfig } from "#app";
 import { useNavigatorLanguage } from "@vueuse/core";
+import { getProperty } from "dot-prop";
 import z from "zod";
 export default defineNuxtPlugin({
   name: "shwfed-nuxt:api",
@@ -13,12 +14,14 @@ export default defineNuxtPlugin({
       onRequest: ({
         options
       }) => {
-        if (nuxt.$config.public.shwfed.apis.headers) {
+        const headersExpression = getProperty(config.apis, "headers");
+        const tokenExpression = getProperty(config.apis, "token");
+        if (typeof headersExpression === "string" && typeof tokenExpression === "string") {
           try {
-            const token = $dsl.evaluate`${config.apis.token}`();
+            const token = $dsl.evaluate`${tokenExpression}`();
             if (token === void 0 || typeof token !== "string")
               throw new Error("Token is undefined");
-            const headers = $dsl.evaluate`${config.apis.headers}`({
+            const headers = $dsl.evaluate`${headersExpression}`({
               token
             });
             for (const [key, value] of Object.entries(z.record(z.string(), z.string()).parse(headers))) {
@@ -33,23 +36,17 @@ export default defineNuxtPlugin({
         }
       },
       onResponse: ({ response }) => {
-        const authorizeUri = config.apis.authorizeUri;
-        const redirectUri = config.apis.redirectUri;
-        if (config.apis.expired !== void 0 && authorizeUri !== void 0 && redirectUri !== void 0) {
+        const expiredExpression = getProperty(config.apis, "expired");
+        const logoutUri = getProperty(config.apis, "logoutUri");
+        if (typeof expiredExpression === "string" && typeof logoutUri === "string") {
           try {
-            const expired = $dsl.evaluate`${config.apis.expired}`({
+            const expired = $dsl.evaluate`${expiredExpression}`({
               response: response._data
             });
             if (expired === true) {
               nuxt.runWithContext(() => {
-                const url = new URL(authorizeUri);
-                const params = new URLSearchParams({
-                  response_type: "code",
-                  client_id: config.apis.clientId,
-                  redirect_uri: redirectUri
-                });
-                url.search = params.toString();
-                navigateTo(url.href, {
+                window.sessionStorage.clear();
+                navigateTo(logoutUri, {
                   external: true,
                   replace: true
                 });
@@ -64,16 +61,11 @@ export default defineNuxtPlugin({
       provide: {
         api,
         logout: () => {
-          const logoutUri = config.apis.logoutUri;
-          if (logoutUri === void 0)
+          const logoutUri = getProperty(config.apis, "logoutUri");
+          if (typeof logoutUri !== "string")
             return;
-          const url = new URL(logoutUri);
-          const params = new URLSearchParams({
-            client_id: config.apis.clientId
-          });
-          url.search = params.toString();
           window.sessionStorage.clear();
-          navigateTo(url.href, {
+          navigateTo(logoutUri, {
             external: true,
             replace: true
           });

package/dist/runtime/utils/command-palette.d.ts

@@ -0,0 +1,71 @@
+export type PaletteId = string | number;
+export type NavigationPaletteInputItem = Readonly<{
+    id: PaletteId;
+    title: string;
+    icon?: string;
+    route: string;
+    keywords?: ReadonlyArray<string>;
+}>;
+export type NavigationPaletteInputGroup = Readonly<{
+    id: PaletteId;
+    title: string;
+    icon?: string;
+    children: ReadonlyArray<NavigationPaletteInputItem>;
+}>;
+export type NavigationPaletteInputEntry = NavigationPaletteInputItem | NavigationPaletteInputGroup;
+export type NavigationPaletteItem = Readonly<{
+    id: PaletteId;
+    title: string;
+    icon?: string;
+    route: string;
+    keywords: Array<string>;
+}>;
+export type NavigationPaletteGroup = Readonly<{
+    id: PaletteId;
+    title: string;
+    icon?: string;
+    children: Array<NavigationPaletteItem>;
+}>;
+export type NavigationPaletteEntry = NavigationPaletteItem | NavigationPaletteGroup;
+export type CommandPaletteInputItem = Readonly<{
+    id: PaletteId;
+    title: string;
+    icon?: string;
+    disabled: boolean;
+    effect?: string;
+    keywords?: ReadonlyArray<string>;
+}>;
+export type CommandPaletteInputGroup = Readonly<{
+    id: PaletteId;
+    title: string;
+    icon?: string;
+    children: ReadonlyArray<CommandPaletteInputItem>;
+}>;
+export type CommandPaletteInputEntry = CommandPaletteInputItem | CommandPaletteInputGroup;
+export type CommandPaletteItem = Readonly<{
+    id: PaletteId;
+    title: string;
+    icon?: string;
+    disabled: boolean;
+    effect?: string;
+    keywords: Array<string>;
+}>;
+export type CommandPaletteGroup = Readonly<{
+    id: PaletteId;
+    title: string;
+    icon?: string;
+    children: Array<CommandPaletteItem>;
+}>;
+export type CommandPaletteEntry = CommandPaletteItem | CommandPaletteGroup;
+export declare const splitNavigationForPalette: (entries: ReadonlyArray<NavigationPaletteInputEntry>) => {
+    favoriteRoutes: Readonly<{
+        id: PaletteId;
+        title: string;
+        icon?: string;
+        route: string;
+        keywords: Array<string>;
+    }>[];
+    navigationEntries: NavigationPaletteEntry[];
+};
+export declare const normalizeCommandsForPalette: (entries: ReadonlyArray<CommandPaletteInputEntry>) => Array<CommandPaletteEntry>;
+export declare const createPaletteItemValue: (prefix: "fav" | "nav" | "cmd", itemId: PaletteId, groupId?: PaletteId) => string;

package/dist/runtime/utils/command-palette.js

@@ -0,0 +1,72 @@
+const normalizeKeywords = (keywords) => {
+  if (keywords === void 0)
+    return [];
+  return [...keywords];
+};
+const normalizeNavigationItem = (item) => {
+  return {
+    id: item.id,
+    title: item.title,
+    icon: item.icon,
+    route: item.route,
+    keywords: normalizeKeywords(item.keywords)
+  };
+};
+export const splitNavigationForPalette = (entries) => {
+  const favoriteRoutes = [];
+  const navigationEntries = [];
+  for (const entry of entries) {
+    if ("children" in entry) {
+      const children = entry.children.map((child) => normalizeNavigationItem(child));
+      if (entry.id === "$favorites") {
+        favoriteRoutes.push(...children);
+        continue;
+      }
+      navigationEntries.push({
+        id: entry.id,
+        title: entry.title,
+        icon: entry.icon,
+        children
+      });
+      continue;
+    }
+    navigationEntries.push(normalizeNavigationItem(entry));
+  }
+  return {
+    favoriteRoutes,
+    navigationEntries
+  };
+};
+const normalizeCommandItem = (item) => {
+  return {
+    id: item.id,
+    title: item.title,
+    icon: item.icon,
+    disabled: item.disabled,
+    effect: item.effect,
+    keywords: normalizeKeywords(item.keywords)
+  };
+};
+export const normalizeCommandsForPalette = (entries) => {
+  const commandEntries = [];
+  for (const entry of entries) {
+    if ("children" in entry) {
+      commandEntries.push({
+        id: entry.id,
+        title: entry.title,
+        icon: entry.icon,
+        children: entry.children.map((child) => normalizeCommandItem(child))
+      });
+      continue;
+    }
+    commandEntries.push(normalizeCommandItem(entry));
+  }
+  return commandEntries;
+};
+export const createPaletteItemValue = (prefix, itemId, groupId) => {
+  const parts = [prefix];
+  if (groupId !== void 0)
+    parts.push(String(groupId));
+  parts.push(String(itemId));
+  return parts.join(":");
+};

package/dist/runtime/utils/command.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const commandActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"route">;
+    to: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"external">;
+    href: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"logout">;
+}, z.core.$strip>], "type">;
+export type CommandAction = z.infer<typeof commandActionSchema>;
+export type ExecuteCommandActionOptions = {
+    logout: () => void;
+};
+export declare const executeCommandAction: (action: CommandAction, options: ExecuteCommandActionOptions) => void;

package/dist/runtime/utils/command.js

@@ -0,0 +1,28 @@
+import { navigateTo } from "#app";
+import { z } from "zod";
+export const commandActionSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("route"),
+    to: z.string()
+  }),
+  z.object({
+    type: z.literal("external"),
+    href: z.string()
+  }),
+  z.object({
+    type: z.literal("logout")
+  })
+]);
+export const executeCommandAction = (action, options) => {
+  switch (action.type) {
+    case "route":
+      navigateTo(action.to);
+      return;
+    case "external":
+      navigateTo(action.href, { external: true });
+      return;
+    case "logout":
+      options.logout();
+      return;
+  }
+};

package/dist/runtime/utils/route.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeRoutePath(path: string): string;
+export declare function isRouteActive(currentPath: string, itemRoute: string): boolean;

package/dist/runtime/utils/route.js

@@ -0,0 +1,14 @@
+export function normalizeRoutePath(path) {
+  if (!path)
+    return "/";
+  const pathWithoutQueryOrHash = path.split(/[?#]/)[0] ?? "/";
+  const normalized = pathWithoutQueryOrHash.replace(/\/+$/, "");
+  return normalized || "/";
+}
+export function isRouteActive(currentPath, itemRoute) {
+  const current = normalizeRoutePath(currentPath);
+  const item = normalizeRoutePath(itemRoute);
+  if (item === "/")
+    return current === "/";
+  return current === item || current.startsWith(`${item}/`);
+}

package/dist/runtime/utils/sidebar-fallback.d.ts

@@ -0,0 +1,16 @@
+type RouteItem = Readonly<{
+    route: string;
+}>;
+type GroupItem = Readonly<{
+    children: Array<RouteItem>;
+}>;
+export type SidebarNavigationItem = RouteItem | GroupItem;
+export declare function getDefaultNavigationRoute(items: Array<SidebarNavigationItem>): string | undefined;
+export declare function hasRootNavigation(items: Array<SidebarNavigationItem>): boolean;
+export declare function applyRootNavigationFallback(options: {
+    path: string;
+    items: Array<SidebarNavigationItem>;
+    tabs: Set<string>;
+    activateTab: (route: string) => void;
+}): void;
+export {};

package/dist/runtime/utils/sidebar-fallback.js

@@ -0,0 +1,32 @@
+import { normalizeRoutePath } from "./route.js";
+function isRouteItem(item) {
+  return "route" in item;
+}
+export function getDefaultNavigationRoute(items) {
+  for (const item of items) {
+    if (isRouteItem(item))
+      return normalizeRoutePath(item.route);
+    const firstChildRoute = item.children[0]?.route;
+    if (firstChildRoute)
+      return normalizeRoutePath(firstChildRoute);
+  }
+  return void 0;
+}
+export function hasRootNavigation(items) {
+  return items.some((item) => {
+    if (isRouteItem(item))
+      return normalizeRoutePath(item.route) === "/";
+    return item.children.some((child) => normalizeRoutePath(child.route) === "/");
+  });
+}
+export function applyRootNavigationFallback(options) {
+  if (normalizeRoutePath(options.path) !== "/")
+    return;
+  if (hasRootNavigation(options.items))
+    return;
+  const fallbackRoute = getDefaultNavigationRoute(options.items);
+  if (!fallbackRoute || fallbackRoute === "/")
+    return;
+  options.tabs.delete("/");
+  options.activateTab(fallbackRoute);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shwfed/nuxt",
-  "version": "0.1.64",
+  "version": "0.1.66",
   "description": "",
   "license": "MIT",
   "type": "module",

package/dist/runtime/server/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../../../.nuxt/tsconfig.server.json",
-}