@jctrans-materials/nuxt4 1.0.41-beta.10

package/dist/module.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+const kit = require('nuxt/kit');
+const defu = require('defu');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const module$1 = kit.defineNuxtModule({
+  meta: {
+    name: "@jctrans-materials/nuxt4",
+    configKey: "jctrans",
+    compatibility: {
+      nuxt: ">=3.0.0"
+    }
+  },
+  defaults: {
+    addStyle: true,
+    sharedConfig: {},
+    tracking: {
+      enabled: true,
+      autoInit: true,
+      directiveName: "gio-track",
+      globalVarName: "__JCTRANS_GIO_CONFIG__",
+      initOptions: {
+        debug: false,
+        trackPage: false,
+        autoTrackPage: false,
+        performance: {
+          monitor: true,
+          exception: true
+        }
+      }
+    }
+  },
+  async setup(options, nuxt) {
+    const { resolve } = kit.createResolver((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('module.cjs', document.baseURI).href)));
+    nuxt.options.runtimeConfig.public ||= {};
+    nuxt.options.runtimeConfig.public.jctrans = defu.defu(
+      nuxt.options.runtimeConfig.public.jctrans,
+      {
+        sharedConfig: options.sharedConfig,
+        tracking: options.tracking
+      }
+    );
+    if (options.addStyle) {
+      nuxt.options.css.push("@jctrans-materials/comps-vue3/index.css");
+    }
+    [
+      "JcSearch",
+      "JcLoginDialog",
+      "ApplyDataDialog",
+      "JcMSearch",
+      "GlobalModal",
+      "JcVerifySlide",
+      "JcCarrierSearch",
+      "AirCarrierSearch",
+      "SeaCarrierSearch",
+      "AirLineSearch",
+      "SeaLineSearch",
+      "LineCascader"
+    ].forEach((name) => {
+      kit.addComponent({
+        name,
+        export: name,
+        filePath: "@jctrans-materials/comps-vue3"
+      });
+    });
+    nuxt.options.build.transpile.push(
+      "@jctrans-materials/comps-vue3",
+      "element-plus"
+    );
+    kit.addPlugin({
+      src: resolve("./runtime/plugin"),
+      mode: "all"
+    });
+    kit.addPlugin({
+      src: resolve("./runtime/gio.client"),
+      mode: "client"
+    });
+    kit.addPlugin({
+      src: resolve("./runtime/gio.server"),
+      mode: "server"
+    });
+    kit.addPlugin({
+      src: resolve("./runtime/plugin.client"),
+      mode: "client"
+    });
+    kit.addTypeTemplate({
+      filename: "types/jctrans-materials-nuxt4.d.ts",
+      src: resolve("./runtime/types.d.ts")
+    });
+    kit.addRouteMiddleware({
+      name: "jctrans-global-auth",
+      path: resolve("./runtime/middleware/auth"),
+      global: true
+    });
+  }
+});
+
+module.exports = module$1;

package/dist/module.d.cts

@@ -0,0 +1,51 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { SharedConfig } from '@jctrans-materials/comps-vue3';
+
+interface TrackingPerformanceNetwork {
+    exclude?: string | RegExp | Array<string | RegExp>;
+}
+interface TrackingPerformanceOptions {
+    monitor?: boolean;
+    exception?: boolean;
+    network?: TrackingPerformanceNetwork | boolean;
+}
+interface TrackingInitOptions {
+    debug?: boolean;
+    serverUrl?: string;
+    trackPage?: boolean;
+    forceLogin?: boolean;
+    idMapping?: boolean;
+    hashtag?: boolean;
+    autoTrackPage?: boolean;
+    performance?: TrackingPerformanceOptions;
+    [key: string]: any;
+}
+interface TrackingOptions {
+    enabled?: boolean;
+    autoInit?: boolean;
+    directiveName?: string;
+    globalVarName?: string;
+    accountId?: string;
+    dataSourceId?: string;
+    appId?: string;
+    initOptions?: TrackingInitOptions;
+}
+interface ModuleOptions {
+    addStyle?: boolean;
+    sharedConfig?: Partial<SharedConfig>;
+    tracking?: TrackingOptions;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+declare module "@nuxt/schema" {
+    interface PublicRuntimeConfig {
+        jctrans?: {
+            sharedConfig?: Partial<SharedConfig>;
+            appId?: string;
+            tracking?: TrackingOptions;
+        };
+    }
+}
+
+export = _default;
+export type { ModuleOptions, TrackingInitOptions, TrackingOptions, TrackingPerformanceNetwork, TrackingPerformanceOptions };

package/dist/module.d.mts

@@ -0,0 +1,51 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { SharedConfig } from '@jctrans-materials/comps-vue3';
+
+interface TrackingPerformanceNetwork {
+    exclude?: string | RegExp | Array<string | RegExp>;
+}
+interface TrackingPerformanceOptions {
+    monitor?: boolean;
+    exception?: boolean;
+    network?: TrackingPerformanceNetwork | boolean;
+}
+interface TrackingInitOptions {
+    debug?: boolean;
+    serverUrl?: string;
+    trackPage?: boolean;
+    forceLogin?: boolean;
+    idMapping?: boolean;
+    hashtag?: boolean;
+    autoTrackPage?: boolean;
+    performance?: TrackingPerformanceOptions;
+    [key: string]: any;
+}
+interface TrackingOptions {
+    enabled?: boolean;
+    autoInit?: boolean;
+    directiveName?: string;
+    globalVarName?: string;
+    accountId?: string;
+    dataSourceId?: string;
+    appId?: string;
+    initOptions?: TrackingInitOptions;
+}
+interface ModuleOptions {
+    addStyle?: boolean;
+    sharedConfig?: Partial<SharedConfig>;
+    tracking?: TrackingOptions;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+declare module "@nuxt/schema" {
+    interface PublicRuntimeConfig {
+        jctrans?: {
+            sharedConfig?: Partial<SharedConfig>;
+            appId?: string;
+            tracking?: TrackingOptions;
+        };
+    }
+}
+
+export { _default as default };
+export type { ModuleOptions, TrackingInitOptions, TrackingOptions, TrackingPerformanceNetwork, TrackingPerformanceOptions };

package/dist/module.d.ts

@@ -0,0 +1,51 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { SharedConfig } from '@jctrans-materials/comps-vue3';
+
+interface TrackingPerformanceNetwork {
+    exclude?: string | RegExp | Array<string | RegExp>;
+}
+interface TrackingPerformanceOptions {
+    monitor?: boolean;
+    exception?: boolean;
+    network?: TrackingPerformanceNetwork | boolean;
+}
+interface TrackingInitOptions {
+    debug?: boolean;
+    serverUrl?: string;
+    trackPage?: boolean;
+    forceLogin?: boolean;
+    idMapping?: boolean;
+    hashtag?: boolean;
+    autoTrackPage?: boolean;
+    performance?: TrackingPerformanceOptions;
+    [key: string]: any;
+}
+interface TrackingOptions {
+    enabled?: boolean;
+    autoInit?: boolean;
+    directiveName?: string;
+    globalVarName?: string;
+    accountId?: string;
+    dataSourceId?: string;
+    appId?: string;
+    initOptions?: TrackingInitOptions;
+}
+interface ModuleOptions {
+    addStyle?: boolean;
+    sharedConfig?: Partial<SharedConfig>;
+    tracking?: TrackingOptions;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+declare module "@nuxt/schema" {
+    interface PublicRuntimeConfig {
+        jctrans?: {
+            sharedConfig?: Partial<SharedConfig>;
+            appId?: string;
+            tracking?: TrackingOptions;
+        };
+    }
+}
+
+export = _default;
+export type { ModuleOptions, TrackingInitOptions, TrackingOptions, TrackingPerformanceNetwork, TrackingPerformanceOptions };

package/dist/module.json

@@ -0,0 +1,12 @@
+{
+  "name": "@jctrans-materials/nuxt4",
+  "configKey": "jctrans",
+  "compatibility": {
+    "nuxt": ">=3.0.0"
+  },
+  "version": "1.0.41-beta.3",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,96 @@
+import { defineNuxtModule, createResolver, addComponent, addPlugin, addTypeTemplate, addRouteMiddleware } from 'nuxt/kit';
+import { defu } from 'defu';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@jctrans-materials/nuxt4",
+    configKey: "jctrans",
+    compatibility: {
+      nuxt: ">=3.0.0"
+    }
+  },
+  defaults: {
+    addStyle: true,
+    sharedConfig: {},
+    tracking: {
+      enabled: true,
+      autoInit: true,
+      directiveName: "gio-track",
+      globalVarName: "__JCTRANS_GIO_CONFIG__",
+      initOptions: {
+        debug: false,
+        trackPage: false,
+        autoTrackPage: false,
+        performance: {
+          monitor: true,
+          exception: true
+        }
+      }
+    }
+  },
+  async setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    nuxt.options.runtimeConfig.public ||= {};
+    nuxt.options.runtimeConfig.public.jctrans = defu(
+      nuxt.options.runtimeConfig.public.jctrans,
+      {
+        sharedConfig: options.sharedConfig,
+        tracking: options.tracking
+      }
+    );
+    if (options.addStyle) {
+      nuxt.options.css.push("@jctrans-materials/comps-vue3/index.css");
+    }
+    [
+      "JcSearch",
+      "JcLoginDialog",
+      "ApplyDataDialog",
+      "JcMSearch",
+      "GlobalModal",
+      "JcVerifySlide",
+      "JcCarrierSearch",
+      "AirCarrierSearch",
+      "SeaCarrierSearch",
+      "AirLineSearch",
+      "SeaLineSearch",
+      "LineCascader"
+    ].forEach((name) => {
+      addComponent({
+        name,
+        export: name,
+        filePath: "@jctrans-materials/comps-vue3"
+      });
+    });
+    nuxt.options.build.transpile.push(
+      "@jctrans-materials/comps-vue3",
+      "element-plus"
+    );
+    addPlugin({
+      src: resolve("./runtime/plugin"),
+      mode: "all"
+    });
+    addPlugin({
+      src: resolve("./runtime/gio.client"),
+      mode: "client"
+    });
+    addPlugin({
+      src: resolve("./runtime/gio.server"),
+      mode: "server"
+    });
+    addPlugin({
+      src: resolve("./runtime/plugin.client"),
+      mode: "client"
+    });
+    addTypeTemplate({
+      filename: "types/jctrans-materials-nuxt4.d.ts",
+      src: resolve("./runtime/types.d.ts")
+    });
+    addRouteMiddleware({
+      name: "jctrans-global-auth",
+      path: resolve("./runtime/middleware/auth"),
+      global: true
+    });
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/gio.client.d.ts

@@ -0,0 +1,3 @@
+import "gio-webjs-sdk";
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/gio.client.js

@@ -0,0 +1,15 @@
+import { defineNuxtPlugin } from "#app";
+import "gio-webjs-sdk";
+export default defineNuxtPlugin({
+  name: "jctrans-gio-sdk-loader",
+  enforce: "pre",
+  setup() {
+    if (process.dev && typeof window !== "undefined") {
+      if (typeof window.gdp !== "function") {
+        console.warn(
+          "[GIO] SDK \u5DF2\u5F15\u5165\uFF0C\u4F46 window.gdp \u4ECD\u4E0D\u53EF\u7528\uFF0C\u8BF7\u68C0\u67E5\u6253\u5305/\u8FD0\u884C\u73AF\u5883"
+        );
+      }
+    }
+  }
+});

package/dist/runtime/gio.server.d.ts

@@ -0,0 +1,28 @@
+declare const _default: import("#app").Plugin<{
+    gio: {
+        init: () => void;
+        track: () => void;
+        isInitialized: () => boolean;
+        isBrowser: () => boolean;
+        setUserId: () => void;
+        clearUserId: () => void;
+        setGeneralProps: () => void;
+        setPageAttributes: () => void;
+        sendPage: () => void;
+    };
+    trackEvent: () => void;
+}> & import("#app").ObjectPlugin<{
+    gio: {
+        init: () => void;
+        track: () => void;
+        isInitialized: () => boolean;
+        isBrowser: () => boolean;
+        setUserId: () => void;
+        clearUserId: () => void;
+        setGeneralProps: () => void;
+        setPageAttributes: () => void;
+        sendPage: () => void;
+    };
+    trackEvent: () => void;
+}>;
+export default _default;

package/dist/runtime/gio.server.js

@@ -0,0 +1,42 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+const normalizeDirectiveName = (value) => {
+  if (typeof value !== "string") return "gio-track";
+  const trimmed = value.trim();
+  if (!trimmed) return "gio-track";
+  return trimmed.replace(/^v-/, "");
+};
+export default defineNuxtPlugin((nuxtApp) => {
+  const runtimeConfig = useRuntimeConfig();
+  const directiveName = normalizeDirectiveName(
+    runtimeConfig.public?.jctrans?.tracking?.directiveName
+  );
+  nuxtApp.vueApp.directive("gio-track", {});
+  if (directiveName !== "gio-track") {
+    nuxtApp.vueApp.directive(directiveName, {});
+  }
+  const mockGio = {
+    init: () => {
+    },
+    track: () => {
+    },
+    isInitialized: () => false,
+    isBrowser: () => false,
+    setUserId: () => {
+    },
+    clearUserId: () => {
+    },
+    setGeneralProps: () => {
+    },
+    setPageAttributes: () => {
+    },
+    sendPage: () => {
+    }
+  };
+  return {
+    provide: {
+      gio: mockGio,
+      trackEvent: () => {
+      }
+    }
+  };
+});

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

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

package/dist/runtime/middleware/auth.js

@@ -0,0 +1,3 @@
+import { defineNuxtRouteMiddleware } from "#app";
+export default defineNuxtRouteMiddleware((to, from) => {
+});

package/dist/runtime/plugin.client.d.ts

@@ -0,0 +1,18 @@
+type TrackAttrs = Record<string, string | number | Array<string | number>>;
+type GioPublicApi = {
+    isInitialized: () => boolean;
+    isBrowser: () => boolean;
+    init: (...args: any[]) => void;
+    track: (eventName: string, attrs?: TrackAttrs, callback?: () => void) => void;
+    setGeneralProps: (props: Record<string, any>) => void;
+    setPageAttributes: (props: Record<string, any>) => void;
+    sendPage: () => void;
+};
+declare const _default: import("#app").Plugin<{
+    gio: GioPublicApi;
+    trackEvent: (eventName: string, attrs?: TrackAttrs) => void;
+}> & import("#app").ObjectPlugin<{
+    gio: GioPublicApi;
+    trackEvent: (eventName: string, attrs?: TrackAttrs) => void;
+}>;
+export default _default;

package/dist/runtime/plugin.client.js

@@ -0,0 +1,251 @@
+import { callOnce, defineNuxtPlugin, useRuntimeConfig, useRouter } from "#app";
+import {
+  getOrCreateClientId,
+  normalizeClickPageAttrs,
+  tracker
+} from "@jctrans-materials/shared";
+import { nextTick } from "vue";
+const pickString = (...values) => {
+  for (const value of values) {
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed) return trimmed;
+    }
+  }
+  return "";
+};
+const pickBoolean = (...values) => {
+  for (const value of values) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "string") {
+      const normalized = value.trim().toLowerCase();
+      if (normalized === "true") return true;
+      if (normalized === "false") return false;
+    }
+  }
+  return void 0;
+};
+const getGlobalTrackingConfig = (globalVarName) => {
+  if (typeof window === "undefined") return {};
+  const currentWindow = window;
+  const fromCustom = currentWindow?.[globalVarName];
+  const fromJctrans = currentWindow?.__JCTRANS_GIO_CONFIG__;
+  const fromDefault = currentWindow?.__GIO_CONFIG__;
+  const finalConfig = fromCustom || fromJctrans || fromDefault;
+  if (finalConfig && typeof finalConfig === "object") {
+    return finalConfig;
+  }
+  return {};
+};
+const normalizeDirectiveName = (value) => {
+  const raw = pickString(value);
+  const name = raw || "gio-track";
+  return name.replace(/^v-/, "");
+};
+const normalizeBinding = (binding) => {
+  const value = binding.value;
+  if (typeof value === "string") {
+    const eventName2 = value.trim();
+    return {
+      eventName: eventName2,
+      trigger: "click",
+      attrs: {},
+      once: false,
+      stop: false,
+      prevent: false
+    };
+  }
+  if (!value || typeof value !== "object") {
+    return {
+      eventName: "",
+      trigger: "click",
+      attrs: {},
+      once: false,
+      stop: false,
+      prevent: false
+    };
+  }
+  const eventName = pickString(value.event, value.name, binding.arg);
+  const trigger = pickString(value.trigger) || "click";
+  const attrs = value.attributes || value.attrs || {};
+  return {
+    eventName,
+    trigger,
+    attrs,
+    once: Boolean(value.once),
+    stop: Boolean(value.stop),
+    prevent: Boolean(value.prevent),
+    callback: typeof value.onTracked === "function" ? value.onTracked : typeof value.callback === "function" ? value.callback : void 0
+  };
+};
+const removeElementHandler = (element) => {
+  const bound = element.__jctransTrackHandler__;
+  if (!bound) return;
+  element.removeEventListener(bound.trigger, bound.handler);
+  delete element.__jctransTrackHandler__;
+};
+const bindTrackHandler = (element, binding, gio) => {
+  removeElementHandler(element);
+  const normalized = normalizeBinding(binding);
+  if (!normalized.eventName) return;
+  const handler = (event) => {
+    if (normalized.prevent && "preventDefault" in event) {
+      event.preventDefault();
+    }
+    if (normalized.stop && "stopPropagation" in event) {
+      event.stopPropagation();
+    }
+    const normalizedAttrs = normalizeClickPageAttrs(
+      normalized.eventName,
+      normalized.attrs
+    );
+    gio.track(normalized.eventName, normalizedAttrs, () => {
+      normalized.callback?.({
+        event,
+        eventName: normalized.eventName,
+        attrs: normalizedAttrs,
+        trigger: normalized.trigger
+      });
+    });
+    if (normalized.once) {
+      removeElementHandler(element);
+    }
+  };
+  element.addEventListener(normalized.trigger, handler);
+  element.__jctransTrackHandler__ = {
+    eventName: normalized.eventName,
+    trigger: normalized.trigger,
+    handler
+  };
+};
+const identifyDeviceIfNeeded = async (forceLogin, key = "jctrans-gio-identify-device") => {
+  if (!import.meta.client || !forceLogin) return;
+  await callOnce(key, () => {
+    const deviceId = getOrCreateClientId();
+    if (!deviceId) return;
+    const gdp = window.gdp;
+    if (typeof gdp === "function") {
+      gdp("identify", deviceId);
+    }
+  });
+};
+export default defineNuxtPlugin((nuxtApp) => {
+  const runtimeConfig = useRuntimeConfig();
+  const router = useRouter();
+  const gio = tracker;
+  const runtimeTracking = runtimeConfig.public?.jctrans?.tracking || {};
+  const globalVarName = pickString(
+    runtimeTracking.globalVarName,
+    "__JCTRANS_GIO_CONFIG__"
+  );
+  const globalTracking = getGlobalTrackingConfig(globalVarName);
+  const metaEnv = import.meta.env || {};
+  const enabled = pickBoolean(runtimeTracking.enabled, globalTracking.enabled);
+  if (enabled === false) {
+    return {
+      provide: {
+        gio,
+        trackEvent: () => {
+        }
+      }
+    };
+  }
+  const initOptions = {
+    ...runtimeTracking.initOptions || {},
+    ...globalTracking.initOptions || {}
+  };
+  if (!initOptions.serverUrl) {
+    const serverUrl = pickString(
+      runtimeConfig.public?.GIO_SERVER_URL,
+      runtimeConfig.public?.gioServerUrl,
+      globalTracking?.serverUrl,
+      runtimeTracking?.serverUrl
+    );
+    if (serverUrl) {
+      initOptions.serverUrl = serverUrl;
+    }
+  }
+  const accountId = pickString(
+    globalTracking.accountId,
+    runtimeTracking.accountId,
+    runtimeConfig.public?.gioAccountId,
+    runtimeConfig.public?.GIO_ACCOUNT_ID,
+    metaEnv.VITE_GIO_ACCOUNT_ID
+  );
+  const dataSourceId = pickString(
+    globalTracking.dataSourceId,
+    runtimeTracking.dataSourceId,
+    runtimeConfig.public?.gioDataSourceId,
+    runtimeConfig.public?.GIO_DATA_SOURCE_ID,
+    metaEnv.VITE_GIO_DATA_SOURCE_ID
+  );
+  const appId = pickString(
+    globalTracking.appId,
+    runtimeTracking.appId,
+    runtimeConfig.public?.gioAppId,
+    runtimeConfig.public?.GIO_APP_ID,
+    metaEnv.VITE_GIO_APP_ID
+  );
+  const autoInit = pickBoolean(
+    runtimeTracking.autoInit,
+    globalTracking.autoInit
+  );
+  const forceLogin = pickBoolean(
+    globalTracking.initOptions?.forceLogin,
+    runtimeTracking.initOptions?.forceLogin,
+    initOptions.forceLogin
+  ) ?? false;
+  if ((autoInit ?? true) && accountId && dataSourceId && !gio.isInitialized()) {
+    if (appId) {
+      gio.init(accountId, dataSourceId, appId, initOptions);
+    } else {
+      gio.init(accountId, dataSourceId, initOptions);
+    }
+    void identifyDeviceIfNeeded(
+      forceLogin,
+      `jctrans-gio-identify-device:${accountId}:${dataSourceId}`
+    );
+  }
+  const trackEvent = (eventName, attrs) => {
+    const normalizedEvent = pickString(eventName);
+    if (!normalizedEvent) return;
+    gio.track(normalizedEvent, normalizeClickPageAttrs(normalizedEvent, attrs));
+  };
+  const directiveName = normalizeDirectiveName(
+    globalTracking.directiveName || runtimeTracking.directiveName
+  );
+  const trackDirective = {
+    mounted(element, binding) {
+      bindTrackHandler(element, binding, gio);
+    },
+    updated(element, binding) {
+      if (JSON.stringify(binding.value) !== JSON.stringify(binding.oldValue)) {
+        bindTrackHandler(element, binding, gio);
+      }
+    },
+    beforeUnmount(element) {
+      removeElementHandler(element);
+    }
+  };
+  nuxtApp.vueApp.directive(directiveName, trackDirective);
+  if (initOptions.trackPage === false && initOptions.autoTrackPage) {
+    if (import.meta.client) {
+      router.afterEach((to) => {
+        setTimeout(async () => {
+          await nextTick();
+          gio.setPageAttributes({
+            route_name: String(to.name || ""),
+            route_path: to.path
+          });
+          gio.sendPage();
+        }, 50);
+      });
+    }
+  }
+  return {
+    provide: {
+      gio,
+      trackEvent
+    }
+  };
+});

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("#app").Plugin<{
+    initAuthSharedConfig: (newConfig: Partial<import("@jctrans-materials/shared").SharedConfig>) => void;
+}> & import("#app").ObjectPlugin<{
+    initAuthSharedConfig: (newConfig: Partial<import("@jctrans-materials/shared").SharedConfig>) => void;
+}>;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,37 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+import {
+  initSharedConfig,
+  createRequest,
+  getAppId
+} from "@jctrans-materials/comps-vue3";
+import { ZINDEX_INJECTION_KEY } from "element-plus";
+import { ref } from "vue";
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.vueApp.provide(ZINDEX_INJECTION_KEY, { zIndex: ref(0) });
+  const runtimeConfig = useRuntimeConfig();
+  const sharedConfig = runtimeConfig.public?.jctrans?.sharedConfig;
+  if (sharedConfig) {
+    const finalBaseURL = runtimeConfig.public.PROD_CLIENT_PROXY_API || sharedConfig.prefixPath || "";
+    const LOGIN_PAGE = runtimeConfig.public.APP_LOGIN_PAGE;
+    initSharedConfig({
+      ...sharedConfig,
+      prefixPath: finalBaseURL
+    });
+    createRequest("fetch", {
+      fetch: $fetch,
+      baseURL: finalBaseURL,
+      onUnauthorized: () => {
+        if (import.meta.client) {
+          const appId = sharedConfig.appId || getAppId();
+          const currentPath = encodeURIComponent(window.location.pathname);
+          window.location.href = `${LOGIN_PAGE || `https://passport.jctrans.com`}/login?appId=${appId}&path=${currentPath}`;
+        }
+      }
+    });
+  }
+  return {
+    provide: {
+      initAuthSharedConfig: initSharedConfig
+    }
+  };
+});

package/dist/runtime/types.d.ts

@@ -0,0 +1,39 @@
+// src/runtime/types.d.ts — Nuxt 4 适配版
+import { initSharedConfig } from "@jctrans-materials/comps-vue3";
+
+type TrackAttrs = Record<string, string | number | Array<string | number>>;
+
+type GioPublicApi = {
+  isInitialized: () => boolean;
+  isBrowser: () => boolean;
+  init: (...args: any[]) => void;
+  track: (eventName: string, attrs?: TrackAttrs, callback?: () => void) => void;
+  setGeneralProps: (props: Record<string, any>) => void;
+  setPageAttributes: (props: Record<string, any>) => void;
+  sendPage: () => void;
+};
+
+declare module "#app" {
+  interface NuxtApp {
+    $initAuthSharedConfig: typeof initSharedConfig;
+    $gio: GioPublicApi;
+    $trackEvent: (eventName: string, attrs?: TrackAttrs) => void;
+  }
+}
+
+declare module "vue" {
+  interface ComponentCustomProperties {
+    $initAuthSharedConfig: typeof initSharedConfig;
+    $gio: GioPublicApi;
+    $trackEvent: (eventName: string, attrs?: TrackAttrs) => void;
+  }
+}
+
+declare global {
+  interface Window {
+    __JCTRANS_GIO_CONFIG__?: Record<string, unknown>;
+    __GIO_CONFIG__?: Record<string, unknown>;
+  }
+}
+
+export {};

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type ModuleOptions, type TrackingInitOptions, type TrackingOptions, type TrackingPerformanceNetwork, type TrackingPerformanceOptions } from './module.mjs'

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@jctrans-materials/nuxt4",
+  "type": "module",
+  "version": "1.0.41-beta.10",
+  "description": "Nuxt 4 module for JCtrans UI components",
+  "exports": {
+    ".": {
+      "types": "./dist/module.d.mts",
+      "import": "./dist/module.mjs",
+      "require": "./dist/module.cjs"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "module": "./dist/module.mjs",
+  "types": "./dist/module.d.mts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nuxt/kit": "^3.0.0",
+    "defu": "6.1.2",
+    "vue": "^3.5.26",
+    "vue-router": "^4.6.4",
+    "@jctrans-materials/comps-vue3": "1.0.41-beta.10",
+    "@jctrans-materials/shared": "1.0.41-beta.10"
+  },
+  "peerDependencies": {
+    "gio-webjs-sdk": "^4.0.0",
+    "nuxt": ">=3.0.0",
+    "@jctrans-materials/comps-vue3": "1.0.41-beta.10",
+    "@jctrans-materials/shared": "1.0.41-beta.10"
+  },
+  "devDependencies": {
+    "@nuxt/module-builder": "latest",
+    "nuxt": "^3.12.1",
+    "unbuild": "^3.6.1"
+  },
+  "scripts": {
+    "build": "nuxt-module-build",
+    "dev": "nuxt dev",
+    "generate": "nuxt generate",
+    "preview": "nuxt preview"
+  }
+}