@shwfed/nuxt 0.1.75 → 0.1.76

package/dist/runtime/composables/useNavigationTabs.js

@@ -1,65 +1,90 @@
 import { useRoute, useRouter } from "#app";
 import { useSessionStorage } from "@vueuse/core";
-import { computed, watch } from "vue";
-import { normalizeRoutePath } from "../utils/route.js";
-export function useNavigationTabs() {
+import { computed, toValue, onMounted } from "vue";
+export function useNavigationTabs(navigations) {
   const tabs = useSessionStorage("navigation-tabs", /* @__PURE__ */ new Set(), {
     writeDefaults: false
   });
   const active = useSessionStorage("navigation-active-tab", void 0, {
     writeDefaults: false
   });
+  const clean = (path) => path.replace(/\/$/g, "");
   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;
+  const has = (raw) => {
+    const path = clean(raw);
+    for (const group of toValue(navigations)) {
+      if ("children" in group) {
+        for (const item of group.children) {
+          if (item.route === path) {
+            return true;
+          }
+        }
+      } else {
+        if (group.route === path) {
+          return true;
+        }
+      }
     }
-    activateTab("/");
   };
-  watch(active, (tab) => {
-    if (!tab)
-      return;
-    const normalizedTab = normalizeRoutePath(tab);
-    if (tab !== normalizedTab) {
-      active.value = normalizedTab;
+  onMounted(() => {
+    const path = clean(route.path);
+    if (!has(path)) {
+      const [first] = Array.from(tabs.value);
+      if (first) {
+        active.value = first;
+        router.replace(first);
+        return;
+      }
+      const nav = toValue(navigations)[0];
+      const fallback = nav && "children" in nav ? nav.children[0]?.route : nav?.route;
+      if (fallback) {
+        router.replace(fallback);
+        active.value = fallback;
+        tabs.value.add(fallback);
+      }
       return;
     }
-    if (route.path !== normalizedTab)
-      router.replace(normalizedTab);
-    if (!tabs.value.has(normalizedTab))
-      tabs.value.add(normalizedTab);
+    if (!tabs.value.has(path))
+      tabs.value.add(path);
+    active.value = path;
   });
-  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
+    nameOf: (path) => {
+      for (const group of toValue(navigations)) {
+        if ("children" in group) {
+          for (const item of group.children) {
+            if (clean(item.route) === clean(path)) {
+              return item.title;
+            }
+          }
+        } else {
+          if (clean(group.route) === clean(path)) {
+            return group.title;
+          }
+        }
+      }
+    },
+    close: (raw) => {
+      const path = clean(raw);
+      if (path === active.value)
+        active.value = Array.from(tabs.value).at(Array.from(tabs.value).findIndex((tab) => tab === active.value) - 1);
+      tabs.value.delete(path);
+    },
+    active: computed({
+      get: () => {
+        if (!active.value) return;
+        return clean(active.value);
+      },
+      set: (raw) => {
+        const path = clean(raw);
+        if (!path) return;
+        router.replace(path);
+        if (!tabs.value.has(path))
+          tabs.value.add(path);
+        active.value = path;
+      }
+    })
   };
 }

package/dist/runtime/middleware/token.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").RouteMiddleware;
+export default _default;

package/dist/runtime/middleware/token.js

@@ -0,0 +1,9 @@
+import { defineNuxtRouteMiddleware } from "#app";
+export default defineNuxtRouteMiddleware((to, from) => {
+  if (from.name) return;
+  const token = to.query["code"] ?? to.query["token"] ?? to.query["access_token"];
+  if (!token || Array.isArray(token)) return;
+  if (import.meta.client) {
+    sessionStorage.setItem("token", token);
+  }
+});

package/dist/runtime/plugins/api/index.d.ts

@@ -1,8 +1,6 @@
 declare const _default: import("#app").Plugin<{
     api: import("nitropack").$Fetch<unknown, import("nitropack").NitroFetchRequest>;
-    logout: () => void;
 }> & import("#app").ObjectPlugin<{
     api: import("nitropack").$Fetch<unknown, import("nitropack").NitroFetchRequest>;
-    logout: () => void;
 }>;
 export default _default;

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

@@ -1,75 +1,25 @@
-import { defineNuxtPlugin, navigateTo, useNuxtApp, useRuntimeConfig } from "#app";
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
 import { useNavigatorLanguage } from "@vueuse/core";
-import { getProperty } from "dot-prop";
-import z from "zod";
 export default defineNuxtPlugin({
   name: "shwfed-nuxt:api",
-  dependsOn: ["shwfed-nuxt:cel"],
-  setup: (nuxt) => {
+  setup: () => {
     const locale = useNavigatorLanguage();
     const config = useRuntimeConfig().public.shwfed;
-    const { $dsl } = useNuxtApp();
     const api = $fetch.create({
-      baseURL: config.apis.apiHost,
+      baseURL: config.api.host,
       onRequest: ({
         options
       }) => {
-        const headersExpression = getProperty(config.apis, "headers");
-        const tokenExpression = getProperty(config.apis, "token");
-        if (typeof headersExpression === "string" && typeof tokenExpression === "string") {
-          try {
-            const token = $dsl.evaluate`${tokenExpression}`();
-            if (token === void 0 || typeof token !== "string")
-              throw new Error("Token is undefined");
-            const headers = $dsl.evaluate`${headersExpression}`({
-              token
-            });
-            for (const [key, value] of Object.entries(z.record(z.string(), z.string()).parse(headers))) {
-              if (!options.headers.has(key))
-                options.headers.set(key, value);
-            }
-          } catch {
-          }
-        }
         if (locale.isSupported && locale.language.value) {
           options.headers.set("Accept-Language", locale.language.value);
         }
-      },
-      onResponse: ({ response }) => {
-        const expiredExpression = getProperty(config.apis, "expired");
-        const logoutUri = getProperty(config.apis, "logoutUri");
-        if (typeof expiredExpression === "string" && typeof logoutUri === "string") {
-          try {
-            const expired = $dsl.evaluate`${expiredExpression}`({
-              response: response._data
-            });
-            if (expired === true) {
-              nuxt.runWithContext(() => {
-                window.sessionStorage.clear();
-                navigateTo(logoutUri, {
-                  external: true,
-                  replace: true
-                });
-              });
-            }
-          } catch {
-          }
-        }
+        const name = config.headers.token ?? "Authorization";
+        options.headers.set(name, sessionStorage.getItem("token") ?? "");
       }
     });
     return {
       provide: {
-        api,
-        logout: () => {
-          const logoutUri = getProperty(config.apis, "logoutUri");
-          if (typeof logoutUri !== "string")
-            return;
-          window.sessionStorage.clear();
-          navigateTo(logoutUri, {
-            external: true,
-            replace: true
-          });
-        }
+        api
       }
     };
   }

package/dist/runtime/plugins/cel/env.js

@@ -68,7 +68,7 @@ export function createEnvironment() {
     return Optional.of(value);
   }).registerType("URL", URL).registerFunction("URL.searchParams(): URLSearchParams", (url) => {
     return url.searchParams;
-  }).registerVariable("location", "URL").registerType("Date", TZDate).registerVariable("now", "Date").registerVariable("today", "Date").registerFunction("date(string): Date", (date) => {
+  }).registerVariable("location", "URL").registerType("Date", TZDate).registerVariable("token", "string").registerVariable("now", "Date").registerVariable("today", "Date").registerFunction("date(string): Date", (date) => {
     return new TZDate(date);
   }).registerOperator("Date < Date", (date1, date2) => {
     return isBefore(date1, date2);

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

@@ -9,12 +9,13 @@ export default defineNuxtPlugin({
     const env = createEnvironment().registerConstant("git", "map<string, string>", config.git).registerConstant("ci", "map<string, dyn>", {
       ...config.ci,
       build: config.ci.build !== void 0 ? BigInt(config.ci.build) : void 0
-    }).registerConstant("apis", "map<string, string>", config.apis);
+    });
     const evaluate = (...args) => (context) => {
       return env.evaluate(String.raw(...args), defu({}, getGlobalDslContext(), context, {
         now: /* @__PURE__ */ new Date(),
         today: /* @__PURE__ */ new Date(),
-        location: new URL(location.href)
+        location: new URL(location.href),
+        token: sessionStorage.getItem("token") ?? ""
       }));
     };
     if (import.meta.client) {

package/dist/runtime/plugins/toast/index.d.ts

@@ -8,9 +8,9 @@ declare const _default: import("#app").Plugin<{
         message: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
         promise: <ToastData>(promise: Promise<ToastData> | (() => Promise<ToastData>), data?: ({
             id?: number | string | undefined;
+            icon?: import("vue").Component | undefined;
             class?: string | undefined;
             style?: import("vue").CSSProperties | undefined;
-            icon?: import("vue").Component | undefined;
             toasterId?: string | undefined;
             component?: import("vue").Component | undefined;
             componentProps?: any;
@@ -61,9 +61,9 @@ declare const _default: import("#app").Plugin<{
         message: (message: string | (() => string | import("vue").Component) | import("vue").Component, data?: import("vue-sonner").ExternalToast) => string | number;
         promise: <ToastData>(promise: Promise<ToastData> | (() => Promise<ToastData>), data?: ({
             id?: number | string | undefined;
+            icon?: import("vue").Component | undefined;
             class?: string | undefined;
             style?: import("vue").CSSProperties | undefined;
-            icon?: import("vue").Component | undefined;
             toasterId?: string | undefined;
             component?: import("vue").Component | undefined;
             componentProps?: any;

package/dist/types.d.mts

@@ -1,3 +1,9 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
 export { default } from './module.mjs'
 
-export { type Env, type ModuleOptions } from './module.mjs'
+export { type Env } from './module.mjs'

package/package.json

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

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

@@ -1,71 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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>, z.ZodObject<{
-    type: z.ZodLiteral<"request">;
-    url: z.ZodString;
-    method: z.ZodOptional<z.ZodEnum<{
-        GET: "GET";
-        POST: "POST";
-        PUT: "PUT";
-        PATCH: "PATCH";
-        DELETE: "DELETE";
-    }>>;
-    body: z.ZodOptional<z.ZodUnknown>;
-    query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, z.core.$strip>], "type">;
-export type CommandAction = z.infer<typeof commandActionSchema>;
-export type ExecuteCommandActionOptions = {
-    logout: () => void;
-    request: (action: Extract<CommandAction, {
-        type: 'request';
-    }>) => Promise<unknown>;
-};
-export declare const executeCommandAction: (action: CommandAction, options: ExecuteCommandActionOptions) => Promise<void>;

package/dist/runtime/utils/command.js

@@ -1,40 +0,0 @@
-import { navigateTo } from "#app";
-import { z } from "zod";
-const requestMethodSchema = z.enum(["GET", "POST", "PUT", "PATCH", "DELETE"]);
-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")
-  }),
-  z.object({
-    type: z.literal("request"),
-    url: z.string(),
-    method: requestMethodSchema.optional(),
-    body: z.unknown().optional(),
-    query: z.record(z.string(), z.unknown()).optional(),
-    headers: z.record(z.string(), z.string()).optional()
-  })
-]);
-export const executeCommandAction = async (action, options) => {
-  switch (action.type) {
-    case "route":
-      navigateTo(action.to);
-      return;
-    case "external":
-      navigateTo(action.href, { external: true });
-      return;
-    case "logout":
-      options.logout();
-      return;
-    case "request":
-      await options.request(action);
-      return;
-  }
-};

package/dist/runtime/utils/navigation-title.d.ts

@@ -1,10 +0,0 @@
-type NavigationLeaf = Readonly<{
-    title: string;
-    route: string;
-}>;
-type NavigationGroup = Readonly<{
-    children: Array<NavigationLeaf>;
-}>;
-type NavigationEntry = NavigationLeaf | NavigationGroup;
-export declare function resolveNavigationTitle(entries: Array<NavigationEntry>, path: string): string;
-export {};

package/dist/runtime/utils/navigation-title.js

@@ -1,28 +0,0 @@
-import { isRouteActive, normalizeRoutePath } from "./route.js";
-export function resolveNavigationTitle(entries, path) {
-  const normalizedPath = normalizeRoutePath(path);
-  let bestTitle;
-  let bestRouteLength = -1;
-  for (const entry of entries) {
-    if ("children" in entry) {
-      for (const child of entry.children) {
-        const normalizedRoute2 = normalizeRoutePath(child.route);
-        if (!isRouteActive(normalizedPath, normalizedRoute2))
-          continue;
-        if (normalizedRoute2.length <= bestRouteLength)
-          continue;
-        bestRouteLength = normalizedRoute2.length;
-        bestTitle = child.title;
-      }
-      continue;
-    }
-    const normalizedRoute = normalizeRoutePath(entry.route);
-    if (!isRouteActive(normalizedPath, normalizedRoute))
-      continue;
-    if (normalizedRoute.length <= bestRouteLength)
-      continue;
-    bestRouteLength = normalizedRoute.length;
-    bestTitle = entry.title;
-  }
-  return bestTitle ?? normalizedPath;
-}

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

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

package/dist/runtime/utils/route.js

@@ -1,14 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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);
-}