@nuxt/devtools 0.0.1 → 0.1.0

package/dist/shared/devtools.861712a3.mjs

@@ -0,0 +1,337 @@
+import require$$1 from 'path';
+import require$$1$1 from 'os';
+import require$$0__default from 'fs';
+
+var globalDirs = {};
+
+const { hasOwnProperty } = Object.prototype;
+
+const eol = typeof process !== 'undefined' &&
+  process.platform === 'win32' ? '\r\n' : '\n';
+
+const encode = (obj, opt) => {
+  const children = [];
+  let out = '';
+
+  if (typeof opt === 'string') {
+    opt = {
+      section: opt,
+      whitespace: false,
+    };
+  } else {
+    opt = opt || Object.create(null);
+    opt.whitespace = opt.whitespace === true;
+  }
+
+  const separator = opt.whitespace ? ' = ' : '=';
+
+  for (const k of Object.keys(obj)) {
+    const val = obj[k];
+    if (val && Array.isArray(val)) {
+      for (const item of val)
+        out += safe(k + '[]') + separator + safe(item) + '\n';
+    } else if (val && typeof val === 'object')
+      children.push(k);
+    else
+      out += safe(k) + separator + safe(val) + eol;
+  }
+
+  if (opt.section && out.length)
+    out = '[' + safe(opt.section) + ']' + eol + out;
+
+  for (const k of children) {
+    const nk = dotSplit(k).join('\\.');
+    const section = (opt.section ? opt.section + '.' : '') + nk;
+    const { whitespace } = opt;
+    const child = encode(obj[k], {
+      section,
+      whitespace,
+    });
+    if (out.length && child.length)
+      out += eol;
+
+    out += child;
+  }
+
+  return out
+};
+
+const dotSplit = str =>
+  str.replace(/\1/g, '\u0002LITERAL\\1LITERAL\u0002')
+    .replace(/\\\./g, '\u0001')
+    .split(/\./)
+    .map(part =>
+      part.replace(/\1/g, '\\.')
+        .replace(/\2LITERAL\\1LITERAL\2/g, '\u0001'));
+
+const decode = str => {
+  const out = Object.create(null);
+  let p = out;
+  let section = null;
+  //          section     |key      = value
+  const re = /^\[([^\]]*)\]$|^([^=]+)(=(.*))?$/i;
+  const lines = str.split(/[\r\n]+/g);
+
+  for (const line of lines) {
+    if (!line || line.match(/^\s*[;#]/))
+      continue
+    const match = line.match(re);
+    if (!match)
+      continue
+    if (match[1] !== undefined) {
+      section = unsafe(match[1]);
+      if (section === '__proto__') {
+        // not allowed
+        // keep parsing the section, but don't attach it.
+        p = Object.create(null);
+        continue
+      }
+      p = out[section] = out[section] || Object.create(null);
+      continue
+    }
+    const keyRaw = unsafe(match[2]);
+    const isArray = keyRaw.length > 2 && keyRaw.slice(-2) === '[]';
+    const key = isArray ? keyRaw.slice(0, -2) : keyRaw;
+    if (key === '__proto__')
+      continue
+    const valueRaw = match[3] ? unsafe(match[4]) : true;
+    const value = valueRaw === 'true' ||
+      valueRaw === 'false' ||
+      valueRaw === 'null' ? JSON.parse(valueRaw)
+      : valueRaw;
+
+    // Convert keys with '[]' suffix to an array
+    if (isArray) {
+      if (!hasOwnProperty.call(p, key))
+        p[key] = [];
+      else if (!Array.isArray(p[key]))
+        p[key] = [p[key]];
+    }
+
+    // safeguard against resetting a previously defined
+    // array by accidentally forgetting the brackets
+    if (Array.isArray(p[key]))
+      p[key].push(value);
+    else
+      p[key] = value;
+  }
+
+  // {a:{y:1},"a.b":{x:2}} --> {a:{y:1,b:{x:2}}}
+  // use a filter to return the keys that have to be deleted.
+  const remove = [];
+  for (const k of Object.keys(out)) {
+    if (!hasOwnProperty.call(out, k) ||
+        typeof out[k] !== 'object' ||
+        Array.isArray(out[k]))
+      continue
+
+    // see if the parent section is also an object.
+    // if so, add it to that, and mark this one for deletion
+    const parts = dotSplit(k);
+    let p = out;
+    const l = parts.pop();
+    const nl = l.replace(/\\\./g, '.');
+    for (const part of parts) {
+      if (part === '__proto__')
+        continue
+      if (!hasOwnProperty.call(p, part) || typeof p[part] !== 'object')
+        p[part] = Object.create(null);
+      p = p[part];
+    }
+    if (p === out && nl === l)
+      continue
+
+    p[nl] = out[k];
+    remove.push(k);
+  }
+  for (const del of remove)
+    delete out[del];
+
+  return out
+};
+
+const isQuoted = val =>
+  (val.charAt(0) === '"' && val.slice(-1) === '"') ||
+    (val.charAt(0) === "'" && val.slice(-1) === "'");
+
+const safe = val =>
+  (typeof val !== 'string' ||
+    val.match(/[=\r\n]/) ||
+    val.match(/^\[/) ||
+    (val.length > 1 &&
+     isQuoted(val)) ||
+    val !== val.trim())
+    ? JSON.stringify(val)
+    : val.replace(/;/g, '\\;').replace(/#/g, '\\#');
+
+const unsafe = (val, doUnesc) => {
+  val = (val || '').trim();
+  if (isQuoted(val)) {
+    // remove the single quotes before calling JSON.parse
+    if (val.charAt(0) === "'")
+      val = val.substr(1, val.length - 2);
+
+    try {
+      val = JSON.parse(val);
+    } catch (_) {}
+  } else {
+    // walk the val to find the first not-escaped ; character
+    let esc = false;
+    let unesc = '';
+    for (let i = 0, l = val.length; i < l; i++) {
+      const c = val.charAt(i);
+      if (esc) {
+        if ('\\;#'.indexOf(c) !== -1)
+          unesc += c;
+        else
+          unesc += '\\' + c;
+
+        esc = false;
+      } else if (';#'.indexOf(c) !== -1)
+        break
+      else if (c === '\\')
+        esc = true;
+      else
+        unesc += c;
+    }
+    if (esc)
+      unesc += '\\';
+
+    return unesc.trim()
+  }
+  return val
+};
+
+var ini = {
+  parse: decode,
+  decode,
+  stringify: encode,
+  encode,
+  safe,
+  unsafe,
+};
+
+(function (exports) {
+	const path = require$$1;
+	const os = require$$1$1;
+	const fs = require$$0__default;
+	const ini$1 = ini;
+
+	const isWindows = process.platform === 'win32';
+
+	const readRc = filePath => {
+		try {
+			return ini$1.parse(fs.readFileSync(filePath, 'utf8')).prefix;
+		} catch {}
+	};
+
+	const getEnvNpmPrefix = () => {
+		// TODO: Remove the `.reduce` call.
+		// eslint-disable-next-line unicorn/no-array-reduce
+		return Object.keys(process.env).reduce((prefix, name) => {
+			return /^npm_config_prefix$/i.test(name) ? process.env[name] : prefix;
+		}, undefined);
+	};
+
+	const getGlobalNpmrc = () => {
+		if (isWindows && process.env.APPDATA) {
+			// Hardcoded contents of `c:\Program Files\nodejs\node_modules\npm\npmrc`
+			return path.join(process.env.APPDATA, '/npm/etc/npmrc');
+		}
+
+		// Homebrew special case: `$(brew --prefix)/lib/node_modules/npm/npmrc`
+		if (process.execPath.includes('/Cellar/node')) {
+			const homebrewPrefix = process.execPath.slice(0, process.execPath.indexOf('/Cellar/node'));
+			return path.join(homebrewPrefix, '/lib/node_modules/npm/npmrc');
+		}
+
+		if (process.execPath.endsWith('/bin/node')) {
+			const installDir = path.dirname(path.dirname(process.execPath));
+			return path.join(installDir, '/etc/npmrc');
+		}
+	};
+
+	const getDefaultNpmPrefix = () => {
+		if (isWindows) {
+			const {APPDATA} = process.env;
+			// `c:\node\node.exe` → `prefix=c:\node\`
+			return APPDATA ? path.join(APPDATA, 'npm') : path.dirname(process.execPath);
+		}
+
+		// `/usr/local/bin/node` → `prefix=/usr/local`
+		return path.dirname(path.dirname(process.execPath));
+	};
+
+	const getNpmPrefix = () => {
+		const envPrefix = getEnvNpmPrefix();
+		if (envPrefix) {
+			return envPrefix;
+		}
+
+		const homePrefix = readRc(path.join(os.homedir(), '.npmrc'));
+		if (homePrefix) {
+			return homePrefix;
+		}
+
+		if (process.env.PREFIX) {
+			return process.env.PREFIX;
+		}
+
+		const globalPrefix = readRc(getGlobalNpmrc());
+		if (globalPrefix) {
+			return globalPrefix;
+		}
+
+		return getDefaultNpmPrefix();
+	};
+
+	const npmPrefix = path.resolve(getNpmPrefix());
+
+	const getYarnWindowsDirectory = () => {
+		if (isWindows && process.env.LOCALAPPDATA) {
+			const dir = path.join(process.env.LOCALAPPDATA, 'Yarn');
+			if (fs.existsSync(dir)) {
+				return dir;
+			}
+		}
+
+		return false;
+	};
+
+	const getYarnPrefix = () => {
+		if (process.env.PREFIX) {
+			return process.env.PREFIX;
+		}
+
+		const windowsPrefix = getYarnWindowsDirectory();
+		if (windowsPrefix) {
+			return windowsPrefix;
+		}
+
+		const configPrefix = path.join(os.homedir(), '.config/yarn');
+		if (fs.existsSync(configPrefix)) {
+			return configPrefix;
+		}
+
+		const homePrefix = path.join(os.homedir(), '.yarn-config');
+		if (fs.existsSync(homePrefix)) {
+			return homePrefix;
+		}
+
+		// Yarn supports the npm conventions but the inverse is not true
+		return npmPrefix;
+	};
+
+	exports.npm = {};
+	exports.npm.prefix = npmPrefix;
+	exports.npm.packages = path.join(npmPrefix, isWindows ? 'node_modules' : 'lib/node_modules');
+	exports.npm.binaries = isWindows ? npmPrefix : path.join(npmPrefix, 'bin');
+
+	const yarnPrefix = path.resolve(getYarnPrefix());
+	exports.yarn = {};
+	exports.yarn.prefix = yarnPrefix;
+	exports.yarn.packages = path.join(yarnPrefix, getYarnWindowsDirectory() ? 'Data/global/node_modules' : 'global/node_modules');
+	exports.yarn.binaries = path.join(exports.yarn.packages, '.bin');
+} (globalDirs));
+
+export { globalDirs as g };

package/dist/types.d.ts

@@ -0,0 +1,313 @@
+import { Nuxt, NuxtOptions, Component, NuxtPage, NuxtLayout, AppConfig } from '@nuxt/schema';
+import { Import, UnimportMeta } from 'unimport';
+import { NuxtApp } from 'nuxt/dist/app/nuxt';
+import { RouteRecordNormalized } from 'vue-router';
+import { VueInspectorClient } from 'vite-plugin-vue-inspector';
+import { Hookable } from 'hookable';
+import { BirpcReturn } from 'birpc';
+import { VNode } from 'vue';
+
+declare function enablePages(nuxt: Nuxt): Promise<void>;
+
+declare const wizard: {
+    enablePages: typeof enablePages;
+};
+type Wizard = typeof wizard;
+type WizardActions = keyof Wizard;
+type WizardArgs<T extends WizardActions> = Wizard[T] extends (nuxt: any, ...args: infer A) => any ? A : never;
+
+interface ModuleOptions {
+    /**
+     * Enable DevTools
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * VS Code Server integration options.
+     */
+    vscode?: VSCodeIntegrationOptions;
+}
+interface ModuleGlobalOptions {
+    /**
+     * List of projects to enable devtools for. Only works when devtools is installed globally.
+     */
+    projects?: string[];
+}
+interface ServerFunctions {
+    getServerConfig(): NuxtOptions;
+    getComponents(): Component[];
+    getComponentsRelationships(): Promise<ComponentRelationship[]>;
+    getAutoImports(): AutoImportsWithMetadata;
+    getServerPages(): NuxtPage[];
+    getCustomTabs(): ModuleCustomTab[];
+    getServerHooks(): HookInfo[];
+    getServerLayouts(): NuxtLayout[];
+    usePackageVersions(): UpdateInfo[];
+    customTabAction(name: string, action: number): Promise<boolean>;
+    runWizard<T extends WizardActions>(name: T, ...args: WizardArgs<T>): Promise<void>;
+    openInEditor(filepath: string): void;
+}
+interface UpdateInfo {
+    name: string;
+    current: string;
+    latest?: string;
+    needsUpdate?: boolean;
+}
+interface AutoImportsWithMetadata {
+    imports: Import[];
+    metadata?: UnimportMeta;
+}
+type ClientUpdateEvent = keyof ServerFunctions;
+interface ClientFunctions {
+    refresh(event: ClientUpdateEvent): void;
+}
+interface RouteInfo extends Pick<RouteRecordNormalized, 'name' | 'path' | 'meta' | 'props' | 'children'> {
+    file?: string;
+}
+interface Payload {
+    url: string;
+    time: number;
+    data?: Record<string, any>;
+    state?: Record<string, any>;
+    functions?: Record<string, any>;
+}
+interface BasicModuleInfo {
+    entryPath?: string;
+    meta?: {
+        name?: string;
+    };
+}
+interface ModuleMetric {
+    name: string;
+    description: string;
+    repo: string;
+    npm: string;
+    icon?: string;
+    github: string;
+    website: string;
+    learn_more: string;
+    category: string;
+    type: ModuleType;
+    maintainers: MaintainerInfo[];
+    contributors: GitHubContributor[];
+    compatibility: ModuleCompatibility;
+}
+interface ModuleCompatibility {
+    nuxt: string;
+    requires: {
+        bridge?: boolean | 'optional';
+    };
+}
+type CompatibilityStatus = 'working' | 'wip' | 'unknown' | 'not-working';
+type ModuleType = 'community' | 'official' | '3rd-party';
+interface MaintainerInfo {
+    name: string;
+    github: string;
+    twitter?: string;
+}
+interface GitHubContributor {
+    login: string;
+    name?: string;
+    avatar_url?: string;
+}
+interface ModuleCustomTab {
+    /**
+     * The name of the tab, must be unique
+     */
+    name: string;
+    /**
+     * Icon of the tab, support any Iconify icons, or a url to an image
+     */
+    icon?: string;
+    /**
+     * Title of the tab
+     */
+    title: string;
+    /**
+     * Main view of the tab
+     */
+    view: ModuleView;
+    /**
+     * Insert static vnode to the tab entry
+     *
+     * Advanced options. You don't usually need this.
+     */
+    extraTabVNode?: VNode;
+}
+interface ModuleLaunchView {
+    /**
+     * A view for module to lazy launch some actions
+     */
+    type: 'launch';
+    title?: string;
+    icon?: string;
+    description: string;
+    /**
+     * Action buttons
+     */
+    actions: ModuleLaunchAction[];
+}
+interface ModuleIframeView {
+    /**
+     * Iframe view
+     */
+    type: 'iframe';
+    /**
+     * Url of the iframe
+     */
+    src: string;
+    /**
+     * Persist the iframe instance even if the tab is not active
+     *
+     * @default true
+     */
+    persistent?: boolean;
+}
+interface ModuleVNodeView {
+    /**
+     * Vue's VNode view
+     */
+    type: 'vnode';
+    /**
+     * Send vnode to the client, they must be static and serializable
+     *
+     * Call `nuxt.hook('devtools:customTabs:refresh')` to trigger manual refresh
+     */
+    vnode: VNode;
+}
+interface ModuleLaunchAction {
+    /**
+     * Label of the action button
+     */
+    label: string;
+    /**
+     * Additional HTML attributes to the action button
+     */
+    attrs?: Record<string, string>;
+    /**
+     * Indicate if the action is pending, will show a loading indicator and disable the button
+     */
+    pending?: boolean;
+    /**
+     * Function to handle the action, this is executed on the server side.
+     * Will automatically refresh the tabs after the action is resolved.
+     */
+    handle?: () => void | Promise<void>;
+    /**
+     * Treat the action as a link, will open the link in a new tab
+     */
+    src?: string;
+}
+type ModuleView = ModuleIframeView | ModuleLaunchView | ModuleVNodeView;
+interface ModuleIframeTabLazyOptions {
+    description?: string;
+    onLoad?: () => Promise<void>;
+}
+interface ModuleBuiltinTab {
+    name: string;
+    icon?: string;
+    title?: string;
+    path?: string;
+    requireClient?: boolean;
+}
+type ModuleTabInfo = ModuleCustomTab | ModuleBuiltinTab;
+interface HookInfo {
+    name: string;
+    start: number;
+    end?: number;
+    duration?: number;
+    listeners: number;
+    executions: number[];
+}
+type VueInspectorData = VueInspectorClient['linkParams'] & VueInspectorClient['position'];
+interface NuxtDevtoolsClientHooks {
+    /**
+     * When the devtools navigates, used for persisting the current tab
+     */
+    'devtools:navigate': (path: string) => void;
+    /**
+     * Event emitted when the component inspector is updated
+     */
+    'host:inspector:update': (data: VueInspectorData) => void;
+    /**
+     * Event emitted when the component inspector is clicked
+     */
+    'host:inspector:click': (baseUrl: string, file: string, line: number, column: number) => void;
+    /**
+     * Event to close the component inspector
+     */
+    'host:inspector:close': () => void;
+    /**
+     * Triggers reactivity manually, since Vue won't be reactive across frames)
+     */
+    'host:update:reactivity': () => void;
+}
+/**
+ * Host client from the App
+ */
+interface NuxtDevtoolsHostClient {
+    nuxt: NuxtApp;
+    appConfig: AppConfig;
+    getHooksMetrics(): HookInfo[];
+    hooks: Hookable<NuxtDevtoolsClientHooks>;
+    inspector?: {
+        instance?: VueInspectorClient;
+        enable: () => void;
+    };
+    closeDevTools(): void;
+}
+interface NuxtDevtoolsClient {
+    rpc: BirpcReturn<ServerFunctions>;
+}
+interface NuxtDevtoolsIframeClient {
+    host: NuxtDevtoolsHostClient;
+    devtools: NuxtDevtoolsClient;
+}
+interface NuxtDevtoolsGlobal {
+    setClient(client: NuxtDevtoolsHostClient): void;
+}
+interface DevToolsFrameState {
+    width: number;
+    height: number;
+    bottom: number;
+    left: number;
+    open: boolean;
+    route: string;
+    position: 'left' | 'right' | 'bottom' | 'top';
+}
+interface DevToolsUISettings {
+    customTabs: boolean;
+    componentsView: 'list' | 'graph';
+    componentsGraphShowNodeModules: boolean;
+    componentsGraphShowPages: boolean;
+    componentsGraphShowLayouts: boolean;
+}
+interface ComponentRelationship {
+    id: string;
+    deps: string[];
+}
+interface VSCodeIntegrationOptions {
+    /**
+     * Enable VS Code Server integration
+     */
+    enabled?: boolean;
+    /**
+     * Start VS Code Server on boot
+     *
+     * @default false
+     */
+    startOnBoot?: boolean;
+    /**
+     * Port to start VS Code Server
+     *
+     * @default 3080
+     */
+    port?: number;
+    /**
+     * Reuse existing server if available (same port)
+     */
+    reuseExistingServer?: boolean;
+}
+
+export { AutoImportsWithMetadata, BasicModuleInfo, ClientFunctions, ClientUpdateEvent, CompatibilityStatus, ComponentRelationship, DevToolsFrameState, DevToolsUISettings, GitHubContributor, HookInfo, MaintainerInfo, ModuleBuiltinTab, ModuleCompatibility, ModuleCustomTab, ModuleGlobalOptions, ModuleIframeTabLazyOptions, ModuleIframeView, ModuleLaunchAction, ModuleLaunchView, ModuleMetric, ModuleOptions, ModuleTabInfo, ModuleType, ModuleVNodeView, ModuleView, NuxtDevtoolsClient, NuxtDevtoolsClientHooks, NuxtDevtoolsGlobal, NuxtDevtoolsHostClient, NuxtDevtoolsIframeClient, Payload, RouteInfo, ServerFunctions, UpdateInfo, VSCodeIntegrationOptions, VueInspectorData };

package/dist/types.mjs

@@ -0,0 +1 @@
+

package/iframe-client.d.ts

@@ -0,0 +1 @@
+export * from './dist/iframe-client'