vue-app-sdk/dist/utils/index2.js

Vue App SDK.

import { useStorageAsync, useStorage } from "../vendors/@vueuse/core/index.js";
import "../vendors/nice-fns/dist/compactObject.js";
import { createLogger } from "../vendors/nice-fns/dist/createLogger.js";
import "../vendors/nice-fns/dist/pascalCase.js";
import { shallowRef, ref } from "vue";
import { loadRouteLocation } from "vue-router";
import isFunction from "../vendors/lodash-es/isFunction.js";
import isArray from "../vendors/lodash-es/isArray.js";
const logger = createLogger("VueAppSDK");
const assign = Object.assign;
function createPersistentRef(options, isAsync, serializer) {
  const { persistent, window, storage, storageKey, shallow = false, value } = options;
  if (persistent) {
    return (isAsync ? useStorageAsync : useStorage)(storageKey, value, storage, {
      shallow,
      window,
      serializer
    });
  }
  return shallow ? shallowRef(value) : ref(value);
}
function isESModule(obj) {
  return obj.__esModule || obj[Symbol.toStringTag] === "Module";
}
async function loadRouteRecord(route) {
  const components = route.components;
  if (!components)
    return route;
  await Promise.all(
    Object.keys(components).reduce((promises, name) => {
      const rawComponent = components[name];
      if (isFunction(rawComponent) && !("displayName" in rawComponent)) {
        promises.push(
          // @ts-expect-error 逻辑无误
          rawComponent().then((resolved) => {
            if (!resolved) {
              return Promise.reject(
                new Error(
                  `Couldn't resolve component "${name}" at "${route.path}". Ensure you passed a function that returns a promise.`
                )
              );
            }
            const resolvedComponent = isESModule(resolved) ? resolved.default : resolved;
            components[name] = resolvedComponent;
          })
        );
      }
      return promises;
    }, [])
  );
  return route;
}
function isUnloadedRoute(route) {
  return Object.values(route.components || {}).some(
    (rawComponent) => isFunction(rawComponent) && !("displayName" in rawComponent)
  );
}
function loadRoute(route) {
  if ("matched" in route && isArray(route))
    return loadRouteLocation(route);
  if ("components" in route && route.components)
    return loadRouteRecord(route);
  return Promise.resolve(route);
}
function getComponentName(component) {
  if (!component)
    return "";
  return component.name || component.displayName || component.__name || "";
}
function syncComponentName(component, name) {
  if (!component)
    return component;
  if (isFunction(component)) {
    if ("displayName" in component)
      return component;
    return () => syncComponentName(component(), name);
  }
  if ("then" in component)
    return component.then((resolved2) => syncComponentName(resolved2, name));
  const resolved = isESModule(component) ? component.default : component;
  assign(resolved, { name });
  return component;
}
async function resolveComponentNameByRoute(route) {
  if (!route)
    return "";
  const promise = isUnloadedRoute(route) ? loadRoute(route) : Promise.resolve(route);
  const result = await promise;
  return getComponentName(result.components && result.components.default);
}
export {
  assign,
  createPersistentRef,
  getComponentName,
  isESModule,
  isUnloadedRoute,
  loadRoute,
  loadRouteRecord,
  logger,
  resolveComponentNameByRoute,
  syncComponentName
};