@sanity/cli-core 0.0.2-alpha.0

package/dist/loaders/studio/studioWorkerLoader.worker.js

@@ -0,0 +1,117 @@
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { isMainThread } from 'node:worker_threads';
+import { moduleResolve } from 'import-meta-resolve';
+import { createServer, loadEnv, mergeConfig } from 'vite';
+import { ViteNodeRunner } from 'vite-node/client';
+import { ViteNodeServer } from 'vite-node/server';
+import { installSourcemapsSupport } from 'vite-node/source-map';
+import { getCliConfig } from '../../config/cli/getCliConfig.js';
+import { isRecord } from '../../util/isRecord.js';
+import { isNotFoundError } from '../../util/NotFoundError.js';
+import * as stubs from './stubs.js';
+if (isMainThread) {
+    throw new Error('Should be child of thread, not the main thread');
+}
+const rootPath = process.env.STUDIO_WORKER_STUDIO_ROOT_PATH;
+if (!rootPath) {
+    throw new Error('Missing `STUDIO_WORKER_STUDIO_ROOT_PATH` environment variable');
+}
+const workerScriptPath = process.env.STUDIO_WORKER_TASK_FILE;
+if (!workerScriptPath) {
+    throw new Error('Missing `STUDIO_WORKER_TASK_FILE` environment variable');
+}
+const mockStubs = stubs;
+const mockedGlobalThis = globalThis;
+for(const key in stubs){
+    if (!(key in mockedGlobalThis)) {
+        mockedGlobalThis[key] = mockStubs[key];
+    }
+}
+// Doesn't have to be correct, just need the root path to be
+const fakeConfigUrl = pathToFileURL(resolve(rootPath, 'sanity.config.mjs'));
+// We'll load `getStudioEnvironmentVariables` from the `sanity/cli` module installed
+// relative to where the studio is located, instead of resolving from where this CLI is
+// running in, in order to ensure we're using the same version as the studio would.
+const sanityCliUrl = await moduleResolve('sanity/cli', fakeConfigUrl);
+const { getStudioEnvironmentVariables } = await import(sanityCliUrl.href);
+if (typeof getStudioEnvironmentVariables !== 'function') {
+    throw new TypeError('Expected `getStudioEnvironmentVariables` from `sanity/cli` to be a function');
+}
+const defaultViteConfig = {
+    build: {
+        target: 'node'
+    },
+    configFile: false,
+    define: {
+        ...getStudioEnvironmentVariables({
+            jsonEncode: true,
+            prefix: 'process.env.'
+        })
+    },
+    logLevel: 'error',
+    optimizeDeps: {
+        disabled: true
+    },
+    root: rootPath,
+    server: {
+        hmr: false,
+        watch: null
+    }
+};
+// Allow the CLI config (`sanity.cli.(js|ts)`) to define a `vite` property which can
+// extend/modify the default vite configuration for the studio.
+let cliConfig;
+try {
+    cliConfig = await getCliConfig(rootPath);
+} catch (err) {
+    if (!isNotFoundError(err)) {
+        console.warn('[warn] Failed to load CLI config:', err);
+    }
+}
+let viteConfig = defaultViteConfig;
+if (typeof cliConfig?.vite === 'function') {
+    viteConfig = await cliConfig.vite(viteConfig, {
+        command: 'build',
+        isSsrBuild: true,
+        mode: 'production'
+    });
+} else if (isRecord(cliConfig?.vite)) {
+    viteConfig = mergeConfig(viteConfig, cliConfig.vite);
+}
+// Vite will build the files we give it - targetting Node.js instead of the browser.
+// We include the inject plugin in order to provide the stubs for the undefined global APIs.
+const server = await createServer(viteConfig);
+// Bit of a hack, but seems necessary based on the `node-vite` binary implementation
+await server.pluginContainer.buildStart({});
+// Load environment variables from `.env` files in the same way as Vite does.
+// Note that Sanity also provides environment variables through `process.env.*` for compat reasons,
+// and so we need to do the same here.
+// @todo is this in line with sanity?
+const env = loadEnv(server.config.mode, server.config.envDir, '');
+for(const key in env){
+    process.env[key] ??= env[key];
+}
+// Now we're providing the glue that ensures node-specific loading and execution works.
+const node = new ViteNodeServer(server);
+// Should make it easier to debug any crashes in the imported code…
+installSourcemapsSupport({
+    getSourceMap: (source)=>node.getSourceMap(source)
+});
+const runner = new ViteNodeRunner({
+    base: server.config.base,
+    async fetchModule (id) {
+        return node.fetchModule(id);
+    },
+    resolveId (id, importer) {
+        return node.resolveId(id, importer);
+    },
+    root: server.config.root
+});
+// Copied from `vite-node` - it appears that this applies the `define` config from
+// vite, but it also takes a surprisingly long time to execute. Not clear at this
+// point why this is, so we should investigate whether it's necessary or not.
+await runner.executeId('/@vite/env');
+await runner.executeId(workerScriptPath);
+
+//# sourceMappingURL=studioWorkerLoader.worker.js.map

package/dist/loaders/studio/studioWorkerLoader.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/loaders/studio/studioWorkerLoader.worker.ts"],"sourcesContent":["import {resolve} from 'node:path'\nimport {pathToFileURL} from 'node:url'\nimport {isMainThread} from 'node:worker_threads'\n\nimport {moduleResolve} from 'import-meta-resolve'\nimport {createServer, type InlineConfig, loadEnv, mergeConfig} from 'vite'\nimport {ViteNodeRunner} from 'vite-node/client'\nimport {ViteNodeServer} from 'vite-node/server'\nimport {installSourcemapsSupport} from 'vite-node/source-map'\n\nimport {getCliConfig} from '../../config/cli/getCliConfig.js'\nimport {type CliConfig} from '../../config/cli/types.js'\nimport {isRecord} from '../../util/isRecord.js'\nimport {isNotFoundError} from '../../util/NotFoundError.js'\nimport * as stubs from './stubs.js'\n\nif (isMainThread) {\n  throw new Error('Should be child of thread, not the main thread')\n}\n\nconst rootPath = process.env.STUDIO_WORKER_STUDIO_ROOT_PATH\nif (!rootPath) {\n  throw new Error('Missing `STUDIO_WORKER_STUDIO_ROOT_PATH` environment variable')\n}\n\nconst workerScriptPath = process.env.STUDIO_WORKER_TASK_FILE\nif (!workerScriptPath) {\n  throw new Error('Missing `STUDIO_WORKER_TASK_FILE` environment variable')\n}\n\nconst mockStubs = stubs as Record<string, unknown>\nconst mockedGlobalThis: Record<string, unknown> = globalThis\nfor (const key in stubs) {\n  if (!(key in mockedGlobalThis)) {\n    mockedGlobalThis[key] = mockStubs[key]\n  }\n}\n\n// Doesn't have to be correct, just need the root path to be\nconst fakeConfigUrl = pathToFileURL(resolve(rootPath, 'sanity.config.mjs'))\n\n// We'll load `getStudioEnvironmentVariables` from the `sanity/cli` module installed\n// relative to where the studio is located, instead of resolving from where this CLI is\n// running in, in order to ensure we're using the same version as the studio would.\nconst sanityCliUrl = await moduleResolve('sanity/cli', fakeConfigUrl)\nconst {getStudioEnvironmentVariables} = await import(sanityCliUrl.href)\nif (typeof getStudioEnvironmentVariables !== 'function') {\n  throw new TypeError('Expected `getStudioEnvironmentVariables` from `sanity/cli` to be a function')\n}\n\nconst defaultViteConfig: InlineConfig = {\n  build: {target: 'node'},\n  configFile: false, // @todo Should use `vite` prop from `sanity.cli.ts` (if any)\n  define: {\n    ...getStudioEnvironmentVariables({jsonEncode: true, prefix: 'process.env.'}),\n  },\n  logLevel: 'error',\n  optimizeDeps: {disabled: true}, // @todo is this necessary? cant remember why was added\n  root: rootPath,\n  server: {\n    hmr: false,\n    watch: null,\n  },\n}\n\n// Allow the CLI config (`sanity.cli.(js|ts)`) to define a `vite` property which can\n// extend/modify the default vite configuration for the studio.\nlet cliConfig: CliConfig | undefined\ntry {\n  cliConfig = await getCliConfig(rootPath)\n} catch (err) {\n  if (!isNotFoundError(err)) {\n    console.warn('[warn] Failed to load CLI config:', err)\n  }\n}\n\nlet viteConfig = defaultViteConfig\nif (typeof cliConfig?.vite === 'function') {\n  viteConfig = (await cliConfig.vite(viteConfig, {\n    command: 'build',\n    isSsrBuild: true,\n    mode: 'production',\n  })) as InlineConfig\n} else if (isRecord(cliConfig?.vite)) {\n  viteConfig = mergeConfig(viteConfig, cliConfig.vite)\n}\n\n// Vite will build the files we give it - targetting Node.js instead of the browser.\n// We include the inject plugin in order to provide the stubs for the undefined global APIs.\nconst server = await createServer(viteConfig)\n\n// Bit of a hack, but seems necessary based on the `node-vite` binary implementation\nawait server.pluginContainer.buildStart({})\n\n// Load environment variables from `.env` files in the same way as Vite does.\n// Note that Sanity also provides environment variables through `process.env.*` for compat reasons,\n// and so we need to do the same here.\n// @todo is this in line with sanity?\nconst env = loadEnv(server.config.mode, server.config.envDir, '')\nfor (const key in env) {\n  process.env[key] ??= env[key]\n}\n\n// Now we're providing the glue that ensures node-specific loading and execution works.\nconst node = new ViteNodeServer(server)\n\n// Should make it easier to debug any crashes in the imported code…\ninstallSourcemapsSupport({\n  getSourceMap: (source) => node.getSourceMap(source),\n})\n\nconst runner = new ViteNodeRunner({\n  base: server.config.base,\n  async fetchModule(id) {\n    return node.fetchModule(id)\n  },\n  resolveId(id, importer) {\n    return node.resolveId(id, importer)\n  },\n  root: server.config.root,\n})\n\n// Copied from `vite-node` - it appears that this applies the `define` config from\n// vite, but it also takes a surprisingly long time to execute. Not clear at this\n// point why this is, so we should investigate whether it's necessary or not.\nawait runner.executeId('/@vite/env')\n\nawait runner.executeId(workerScriptPath)\n"],"names":["resolve","pathToFileURL","isMainThread","moduleResolve","createServer","loadEnv","mergeConfig","ViteNodeRunner","ViteNodeServer","installSourcemapsSupport","getCliConfig","isRecord","isNotFoundError","stubs","Error","rootPath","process","env","STUDIO_WORKER_STUDIO_ROOT_PATH","workerScriptPath","STUDIO_WORKER_TASK_FILE","mockStubs","mockedGlobalThis","globalThis","key","fakeConfigUrl","sanityCliUrl","getStudioEnvironmentVariables","href","TypeError","defaultViteConfig","build","target","configFile","define","jsonEncode","prefix","logLevel","optimizeDeps","disabled","root","server","hmr","watch","cliConfig","err","console","warn","viteConfig","vite","command","isSsrBuild","mode","pluginContainer","buildStart","config","envDir","node","getSourceMap","source","runner","base","fetchModule","id","resolveId","importer","executeId"],"mappings":"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"}

package/dist/loaders/studio/studioWorkerTask.d.ts

@@ -0,0 +1,40 @@
+import { type WorkerOptions } from 'node:worker_threads';
+import { type RequireProps } from '../../types.js';
+/**
+ * Options for the studio worker task
+ *
+ * @internal
+ */
+interface StudioWorkerTaskOptions extends RequireProps<WorkerOptions, 'name'> {
+    studioRootPath: string;
+}
+/**
+ * Executes a worker file in a Sanity Studio browser context.
+ *
+ * This uses a combination of vite for "bundling" + jsdom for emulating a browser
+ * environment under the hood, which means that the same thing that will work in vite
+ * _should_ work in the worker - to a degree. If the user has defined any typescript
+ * path aliases, these will have to be added as aliases to the vite config - the same
+ * behavior as you would see with regular vite. Other things that are accounted for:
+ *
+ * - TypeScript support (+JSX, enums and other "compilation needed" features)
+ * - CSS, font and other file imports will resolve to a file path
+ * - CSS module imports will resolve to a javascript object of class names
+ * - Environment variables are available both as `import.meta.env` and `process.env`,
+ *   and `.env` files are loaded in the same way that they would in a Sanity studio.
+ * - Browser globals not available in a Node.js environment but _are_ provided by JSDOM
+ *   are defined directly to the Node environment as globals. While this polutes the
+ *   global namespace, it is done only in the worker thread.
+ * - Certain browser globals that are _not_ available in JSDOM are also provided to the
+ *   global namespace - things like `requestIdleCallback`, `IntersectionObserver` etc.
+ *   These are provided with a minimal stub implementation to make them not crash.
+ *
+ * @param filePath - Path to the worker file (`.ts` works and is encouraged)
+ * @param options - Options to pass to the worker
+ * @returns A promise that resolves with the message from the worker
+ * @throws If the file does not exist
+ * @throws If the worker exits with a non-zero code
+ * @internal
+ */
+export declare function studioWorkerTask(filePath: URL, options: StudioWorkerTaskOptions): Promise<unknown>;
+export {};

package/dist/loaders/studio/studioWorkerTask.js

@@ -0,0 +1,69 @@
+import { Worker } from 'node:worker_threads';
+import { isRecord } from '../../util/isRecord.js';
+/**
+ * Executes a worker file in a Sanity Studio browser context.
+ *
+ * This uses a combination of vite for "bundling" + jsdom for emulating a browser
+ * environment under the hood, which means that the same thing that will work in vite
+ * _should_ work in the worker - to a degree. If the user has defined any typescript
+ * path aliases, these will have to be added as aliases to the vite config - the same
+ * behavior as you would see with regular vite. Other things that are accounted for:
+ *
+ * - TypeScript support (+JSX, enums and other "compilation needed" features)
+ * - CSS, font and other file imports will resolve to a file path
+ * - CSS module imports will resolve to a javascript object of class names
+ * - Environment variables are available both as `import.meta.env` and `process.env`,
+ *   and `.env` files are loaded in the same way that they would in a Sanity studio.
+ * - Browser globals not available in a Node.js environment but _are_ provided by JSDOM
+ *   are defined directly to the Node environment as globals. While this polutes the
+ *   global namespace, it is done only in the worker thread.
+ * - Certain browser globals that are _not_ available in JSDOM are also provided to the
+ *   global namespace - things like `requestIdleCallback`, `IntersectionObserver` etc.
+ *   These are provided with a minimal stub implementation to make them not crash.
+ *
+ * @param filePath - Path to the worker file (`.ts` works and is encouraged)
+ * @param options - Options to pass to the worker
+ * @returns A promise that resolves with the message from the worker
+ * @throws If the file does not exist
+ * @throws If the worker exits with a non-zero code
+ * @internal
+ */ export function studioWorkerTask(filePath, options) {
+    return new Promise((resolve, reject)=>{
+        if (!/\.worker\.(js|ts)$/.test(filePath.pathname)) {
+            throw new Error('Studio worker tasks must include `.worker.(js|ts)` in path');
+        }
+        const worker = new Worker(new URL('studioWorkerLoader.worker.js', import.meta.url), {
+            ...options,
+            env: {
+                ...isRecord(options.env) ? options.env : process.env,
+                STUDIO_WORKER_STUDIO_ROOT_PATH: options.studioRootPath,
+                STUDIO_WORKER_TASK_FILE: filePath.pathname
+            }
+        });
+        worker.addListener('error', function onWorkerError(err) {
+            reject(new Error(`Fail to load file through worker: ${err.message}`));
+            cleanup();
+        });
+        worker.addListener('exit', function onWorkerExit(code) {
+            if (code > 0) {
+                reject(new Error(`Worker exited with code ${code}`));
+            }
+        });
+        worker.addListener('messageerror', function onWorkerMessageError(err) {
+            reject(new Error(`Fail to parse message from worker: ${err}`));
+            cleanup();
+        });
+        worker.addListener('message', function onWorkerMessage(message) {
+            resolve(message);
+            cleanup();
+        });
+        function cleanup() {
+            // Allow the worker a _bit_ of time to clean up, but ensure that we don't have
+            // lingering processes hanging around forever if the worker doesn't exit on its
+            // own.
+            setImmediate(()=>worker.terminate());
+        }
+    });
+}
+
+//# sourceMappingURL=studioWorkerTask.js.map

package/dist/loaders/studio/studioWorkerTask.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/loaders/studio/studioWorkerTask.ts"],"sourcesContent":["import {Worker, type WorkerOptions} from 'node:worker_threads'\n\nimport {type RequireProps} from '../../types.js'\nimport {isRecord} from '../../util/isRecord.js'\n\n/**\n * Options for the studio worker task\n *\n * @internal\n */\ninterface StudioWorkerTaskOptions extends RequireProps<WorkerOptions, 'name'> {\n  studioRootPath: string\n}\n\n/**\n * Executes a worker file in a Sanity Studio browser context.\n *\n * This uses a combination of vite for \"bundling\" + jsdom for emulating a browser\n * environment under the hood, which means that the same thing that will work in vite\n * _should_ work in the worker - to a degree. If the user has defined any typescript\n * path aliases, these will have to be added as aliases to the vite config - the same\n * behavior as you would see with regular vite. Other things that are accounted for:\n *\n * - TypeScript support (+JSX, enums and other \"compilation needed\" features)\n * - CSS, font and other file imports will resolve to a file path\n * - CSS module imports will resolve to a javascript object of class names\n * - Environment variables are available both as `import.meta.env` and `process.env`,\n *   and `.env` files are loaded in the same way that they would in a Sanity studio.\n * - Browser globals not available in a Node.js environment but _are_ provided by JSDOM\n *   are defined directly to the Node environment as globals. While this polutes the\n *   global namespace, it is done only in the worker thread.\n * - Certain browser globals that are _not_ available in JSDOM are also provided to the\n *   global namespace - things like `requestIdleCallback`, `IntersectionObserver` etc.\n *   These are provided with a minimal stub implementation to make them not crash.\n *\n * @param filePath - Path to the worker file (`.ts` works and is encouraged)\n * @param options - Options to pass to the worker\n * @returns A promise that resolves with the message from the worker\n * @throws If the file does not exist\n * @throws If the worker exits with a non-zero code\n * @internal\n */\nexport function studioWorkerTask(\n  filePath: URL,\n  options: StudioWorkerTaskOptions,\n): Promise<unknown> {\n  return new Promise((resolve, reject) => {\n    if (!/\\.worker\\.(js|ts)$/.test(filePath.pathname)) {\n      throw new Error('Studio worker tasks must include `.worker.(js|ts)` in path')\n    }\n\n    const worker = new Worker(new URL('studioWorkerLoader.worker.js', import.meta.url), {\n      ...options,\n      env: {\n        ...(isRecord(options.env) ? options.env : process.env),\n        STUDIO_WORKER_STUDIO_ROOT_PATH: options.studioRootPath,\n        STUDIO_WORKER_TASK_FILE: filePath.pathname,\n      },\n    })\n\n    worker.addListener('error', function onWorkerError(err) {\n      reject(new Error(`Fail to load file through worker: ${err.message}`))\n      cleanup()\n    })\n    worker.addListener('exit', function onWorkerExit(code) {\n      if (code > 0) {\n        reject(new Error(`Worker exited with code ${code}`))\n      }\n    })\n    worker.addListener('messageerror', function onWorkerMessageError(err) {\n      reject(new Error(`Fail to parse message from worker: ${err}`))\n      cleanup()\n    })\n    worker.addListener('message', function onWorkerMessage(message) {\n      resolve(message)\n      cleanup()\n    })\n\n    function cleanup() {\n      // Allow the worker a _bit_ of time to clean up, but ensure that we don't have\n      // lingering processes hanging around forever if the worker doesn't exit on its\n      // own.\n      setImmediate(() => worker.terminate())\n    }\n  })\n}\n"],"names":["Worker","isRecord","studioWorkerTask","filePath","options","Promise","resolve","reject","test","pathname","Error","worker","URL","url","env","process","STUDIO_WORKER_STUDIO_ROOT_PATH","studioRootPath","STUDIO_WORKER_TASK_FILE","addListener","onWorkerError","err","message","cleanup","onWorkerExit","code","onWorkerMessageError","onWorkerMessage","setImmediate","terminate"],"mappings":"AAAA,SAAQA,MAAM,QAA2B,sBAAqB;AAG9D,SAAQC,QAAQ,QAAO,yBAAwB;AAW/C;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BC,GACD,OAAO,SAASC,iBACdC,QAAa,EACbC,OAAgC;IAEhC,OAAO,IAAIC,QAAQ,CAACC,SAASC;QAC3B,IAAI,CAAC,qBAAqBC,IAAI,CAACL,SAASM,QAAQ,GAAG;YACjD,MAAM,IAAIC,MAAM;QAClB;QAEA,MAAMC,SAAS,IAAIX,OAAO,IAAIY,IAAI,gCAAgC,YAAYC,GAAG,GAAG;YAClF,GAAGT,OAAO;YACVU,KAAK;gBACH,GAAIb,SAASG,QAAQU,GAAG,IAAIV,QAAQU,GAAG,GAAGC,QAAQD,GAAG;gBACrDE,gCAAgCZ,QAAQa,cAAc;gBACtDC,yBAAyBf,SAASM,QAAQ;YAC5C;QACF;QAEAE,OAAOQ,WAAW,CAAC,SAAS,SAASC,cAAcC,GAAG;YACpDd,OAAO,IAAIG,MAAM,CAAC,kCAAkC,EAAEW,IAAIC,OAAO,EAAE;YACnEC;QACF;QACAZ,OAAOQ,WAAW,CAAC,QAAQ,SAASK,aAAaC,IAAI;YACnD,IAAIA,OAAO,GAAG;gBACZlB,OAAO,IAAIG,MAAM,CAAC,wBAAwB,EAAEe,MAAM;YACpD;QACF;QACAd,OAAOQ,WAAW,CAAC,gBAAgB,SAASO,qBAAqBL,GAAG;YAClEd,OAAO,IAAIG,MAAM,CAAC,mCAAmC,EAAEW,KAAK;YAC5DE;QACF;QACAZ,OAAOQ,WAAW,CAAC,WAAW,SAASQ,gBAAgBL,OAAO;YAC5DhB,QAAQgB;YACRC;QACF;QAEA,SAASA;YACP,8EAA8E;YAC9E,+EAA+E;YAC/E,OAAO;YACPK,aAAa,IAAMjB,OAAOkB,SAAS;QACrC;IACF;AACF"}

package/dist/loaders/tsx/tsxWorkerLoader.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/loaders/tsx/tsxWorkerLoader.worker.js

@@ -0,0 +1,12 @@
+import { tsImport } from 'tsx/esm/api';
+const workerScript = process.env.TSX_WORKER_TASK_SCRIPT;
+if (workerScript) {
+    await tsImport(workerScript, {
+        parentURL: import.meta.url,
+        tsconfig: process.env.TSX_TSCONFIG_PATH
+    });
+} else {
+    throw new Error('`TX_WORKER_TASK_SCRIPT` not defined');
+}
+
+//# sourceMappingURL=tsxWorkerLoader.worker.js.map

package/dist/loaders/tsx/tsxWorkerLoader.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/loaders/tsx/tsxWorkerLoader.worker.ts"],"sourcesContent":["import {tsImport} from 'tsx/esm/api'\n\nconst workerScript = process.env.TSX_WORKER_TASK_SCRIPT\n\nif (workerScript) {\n  await tsImport(workerScript, {\n    parentURL: import.meta.url,\n    tsconfig: process.env.TSX_TSCONFIG_PATH,\n  })\n} else {\n  throw new Error('`TX_WORKER_TASK_SCRIPT` not defined')\n}\n"],"names":["tsImport","workerScript","process","env","TSX_WORKER_TASK_SCRIPT","parentURL","url","tsconfig","TSX_TSCONFIG_PATH","Error"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,cAAa;AAEpC,MAAMC,eAAeC,QAAQC,GAAG,CAACC,sBAAsB;AAEvD,IAAIH,cAAc;IAChB,MAAMD,SAASC,cAAc;QAC3BI,WAAW,YAAYC,GAAG;QAC1BC,UAAUL,QAAQC,GAAG,CAACK,iBAAiB;IACzC;AACF,OAAO;IACL,MAAM,IAAIC,MAAM;AAClB"}

package/dist/loaders/tsx/tsxWorkerTask.d.ts

@@ -0,0 +1,28 @@
+import { URL } from 'node:url';
+import { type WorkerOptions } from 'node:worker_threads';
+import { type RequireProps } from '../../types.js';
+/**
+ * Options for the tsx worker task
+ *
+ * @internal
+ */
+interface TsxWorkerTaskOptions extends RequireProps<WorkerOptions, 'name'> {
+    rootPath: string;
+}
+/**
+ * Executes a worker file with tsx registered. This means you can import other
+ * typescript with fairly rich syntax, and still have that only apply to the worker
+ * thread instead of the full parent process. The worker should emit a message when
+ * complete using `parentPort`. Once it has received a single message will resolve the
+ * returned promise with that message. If you are expecting multiple messages, you will
+ * have to implement another method ;)
+ *
+ * @param filePath - Path to the worker file
+ * @param options - Options to pass to the worker
+ * @returns A promise that resolves with the message from the worker
+ * @throws If the file does not exist
+ * @throws If the worker exits with a non-zero code
+ * @internal
+ */
+export declare function tsxWorkerTask<T = unknown>(filePath: URL, options: TsxWorkerTaskOptions): Promise<T>;
+export {};

package/dist/loaders/tsx/tsxWorkerTask.js

@@ -0,0 +1,61 @@
+import { URL } from 'node:url';
+import { Worker } from 'node:worker_threads';
+import { getTsconfig } from 'get-tsconfig';
+import { isRecord } from '../../util/isRecord.js';
+/**
+ * Executes a worker file with tsx registered. This means you can import other
+ * typescript with fairly rich syntax, and still have that only apply to the worker
+ * thread instead of the full parent process. The worker should emit a message when
+ * complete using `parentPort`. Once it has received a single message will resolve the
+ * returned promise with that message. If you are expecting multiple messages, you will
+ * have to implement another method ;)
+ *
+ * @param filePath - Path to the worker file
+ * @param options - Options to pass to the worker
+ * @returns A promise that resolves with the message from the worker
+ * @throws If the file does not exist
+ * @throws If the worker exits with a non-zero code
+ * @internal
+ */ export function tsxWorkerTask(filePath, options) {
+    const tsconfig = getTsconfig(options.rootPath);
+    const env = {
+        ...isRecord(options.env) ? options.env : process.env,
+        ...tsconfig?.path ? {
+            TSX_TSCONFIG_PATH: tsconfig.path
+        } : {},
+        TSX_WORKER_TASK_SCRIPT: filePath.pathname
+    };
+    const worker = new Worker(new URL('tsxWorkerLoader.worker.js', import.meta.url), {
+        ...options,
+        env
+    });
+    return new Promise((resolve, reject)=>{
+        worker.addListener('error', function onWorkerError(err) {
+            reject(new Error(`Failed to load file through worker: ${err.message}`, {
+                cause: err
+            }));
+            cleanup();
+        });
+        worker.addListener('exit', function onWorkerExit(code) {
+            if (code > 0) {
+                reject(new Error(`Worker exited with code ${code}`));
+            }
+        });
+        worker.addListener('messageerror', function onWorkerMessageError(err) {
+            reject(new Error(`Fail to parse message from worker: ${err}`));
+            cleanup();
+        });
+        worker.addListener('message', function onWorkerMessage(message) {
+            resolve(message);
+            cleanup();
+        });
+        function cleanup() {
+            // Allow the worker a _bit_ of time to clean up, but ensure that we don't have
+            // lingering processes hanging around forever if the worker doesn't exit on its
+            // own.
+            setImmediate(()=>worker.terminate());
+        }
+    });
+}
+
+//# sourceMappingURL=tsxWorkerTask.js.map

package/dist/loaders/tsx/tsxWorkerTask.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/loaders/tsx/tsxWorkerTask.ts"],"sourcesContent":["import {URL} from 'node:url'\nimport {Worker, type WorkerOptions} from 'node:worker_threads'\n\nimport {getTsconfig} from 'get-tsconfig'\n\nimport {type RequireProps} from '../../types.js'\nimport {isRecord} from '../../util/isRecord.js'\n\n/**\n * Options for the tsx worker task\n *\n * @internal\n */\ninterface TsxWorkerTaskOptions extends RequireProps<WorkerOptions, 'name'> {\n  rootPath: string\n}\n\n/**\n * Executes a worker file with tsx registered. This means you can import other\n * typescript with fairly rich syntax, and still have that only apply to the worker\n * thread instead of the full parent process. The worker should emit a message when\n * complete using `parentPort`. Once it has received a single message will resolve the\n * returned promise with that message. If you are expecting multiple messages, you will\n * have to implement another method ;)\n *\n * @param filePath - Path to the worker file\n * @param options - Options to pass to the worker\n * @returns A promise that resolves with the message from the worker\n * @throws If the file does not exist\n * @throws If the worker exits with a non-zero code\n * @internal\n */\nexport function tsxWorkerTask<T = unknown>(\n  filePath: URL,\n  options: TsxWorkerTaskOptions,\n): Promise<T> {\n  const tsconfig = getTsconfig(options.rootPath)\n\n  const env = {\n    ...(isRecord(options.env) ? options.env : process.env),\n    ...(tsconfig?.path ? {TSX_TSCONFIG_PATH: tsconfig.path} : {}),\n    TSX_WORKER_TASK_SCRIPT: filePath.pathname,\n  }\n\n  const worker = new Worker(new URL('tsxWorkerLoader.worker.js', import.meta.url), {\n    ...options,\n    env,\n  })\n\n  return new Promise((resolve, reject) => {\n    worker.addListener('error', function onWorkerError(err) {\n      reject(new Error(`Failed to load file through worker: ${err.message}`, {cause: err}))\n      cleanup()\n    })\n    worker.addListener('exit', function onWorkerExit(code) {\n      if (code > 0) {\n        reject(new Error(`Worker exited with code ${code}`))\n      }\n    })\n    worker.addListener('messageerror', function onWorkerMessageError(err) {\n      reject(new Error(`Fail to parse message from worker: ${err}`))\n      cleanup()\n    })\n    worker.addListener('message', function onWorkerMessage(message) {\n      resolve(message)\n      cleanup()\n    })\n\n    function cleanup() {\n      // Allow the worker a _bit_ of time to clean up, but ensure that we don't have\n      // lingering processes hanging around forever if the worker doesn't exit on its\n      // own.\n      setImmediate(() => worker.terminate())\n    }\n  })\n}\n"],"names":["URL","Worker","getTsconfig","isRecord","tsxWorkerTask","filePath","options","tsconfig","rootPath","env","process","path","TSX_TSCONFIG_PATH","TSX_WORKER_TASK_SCRIPT","pathname","worker","url","Promise","resolve","reject","addListener","onWorkerError","err","Error","message","cause","cleanup","onWorkerExit","code","onWorkerMessageError","onWorkerMessage","setImmediate","terminate"],"mappings":"AAAA,SAAQA,GAAG,QAAO,WAAU;AAC5B,SAAQC,MAAM,QAA2B,sBAAqB;AAE9D,SAAQC,WAAW,QAAO,eAAc;AAGxC,SAAQC,QAAQ,QAAO,yBAAwB;AAW/C;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAASC,cACdC,QAAa,EACbC,OAA6B;IAE7B,MAAMC,WAAWL,YAAYI,QAAQE,QAAQ;IAE7C,MAAMC,MAAM;QACV,GAAIN,SAASG,QAAQG,GAAG,IAAIH,QAAQG,GAAG,GAAGC,QAAQD,GAAG;QACrD,GAAIF,UAAUI,OAAO;YAACC,mBAAmBL,SAASI,IAAI;QAAA,IAAI,CAAC,CAAC;QAC5DE,wBAAwBR,SAASS,QAAQ;IAC3C;IAEA,MAAMC,SAAS,IAAId,OAAO,IAAID,IAAI,6BAA6B,YAAYgB,GAAG,GAAG;QAC/E,GAAGV,OAAO;QACVG;IACF;IAEA,OAAO,IAAIQ,QAAQ,CAACC,SAASC;QAC3BJ,OAAOK,WAAW,CAAC,SAAS,SAASC,cAAcC,GAAG;YACpDH,OAAO,IAAII,MAAM,CAAC,oCAAoC,EAAED,IAAIE,OAAO,EAAE,EAAE;gBAACC,OAAOH;YAAG;YAClFI;QACF;QACAX,OAAOK,WAAW,CAAC,QAAQ,SAASO,aAAaC,IAAI;YACnD,IAAIA,OAAO,GAAG;gBACZT,OAAO,IAAII,MAAM,CAAC,wBAAwB,EAAEK,MAAM;YACpD;QACF;QACAb,OAAOK,WAAW,CAAC,gBAAgB,SAASS,qBAAqBP,GAAG;YAClEH,OAAO,IAAII,MAAM,CAAC,mCAAmC,EAAED,KAAK;YAC5DI;QACF;QACAX,OAAOK,WAAW,CAAC,WAAW,SAASU,gBAAgBN,OAAO;YAC5DN,QAAQM;YACRE;QACF;QAEA,SAASA;YACP,8EAA8E;YAC9E,+EAA+E;YAC/E,OAAO;YACPK,aAAa,IAAMhB,OAAOiB,SAAS;QACrC;IACF;AACF"}

package/dist/services/apiClient.d.ts

@@ -0,0 +1,39 @@
+import { type SanityClient } from '@sanity/client';
+/**
+ * @internal
+ */
+export interface GlobalCliClientOptions {
+    /**
+     * The API version to use for this client.
+     */
+    apiVersion: string;
+    /**
+     * Whether to require a user to be authenticated to use this client.
+     * Default: `false`.
+     * Throws an error if `true` and user is not authenticated.
+     */
+    requireUser?: boolean;
+}
+/**
+ * Create a "global" (unscoped) Sanity API client.
+ *
+ * @param options - The options to use for the client.
+ * @returns Promise that resolves to a configured Sanity API client.
+ */
+export declare function getGlobalCliClient({ apiVersion, requireUser, }: GlobalCliClientOptions): Promise<SanityClient>;
+/**
+ * @internal
+ */
+export interface ProjectCliClientOptions {
+    apiVersion: string;
+    projectId: string;
+    dataset?: string;
+    requireUser?: boolean;
+}
+/**
+ * Create a "global" (unscoped) Sanity API client.
+ *
+ * @param options - The options to use for the client.
+ * @returns Promise that resolves to a configured Sanity API client.
+ */
+export declare function getProjectCliClient({ apiVersion, dataset, projectId, requireUser, }: ProjectCliClientOptions): Promise<SanityClient>;

package/dist/services/apiClient.js

@@ -0,0 +1,88 @@
+import { ux } from '@oclif/core';
+import { createClient, requester as defaultRequester } from '@sanity/client';
+import { generateHelpUrl } from '../util/generateHelpUrl.js';
+import { isHttpError } from '../util/isHttpError.js';
+import { getCliToken } from './getCliToken.js';
+const apiHosts = {
+    staging: 'https://api.sanity.work'
+};
+const CLI_REQUEST_TAG_PREFIX = 'sanity.cli';
+/**
+ * Create a "global" (unscoped) Sanity API client.
+ *
+ * @param options - The options to use for the client.
+ * @returns Promise that resolves to a configured Sanity API client.
+ */ export async function getGlobalCliClient({ apiVersion, requireUser }) {
+    const requester = defaultRequester.clone();
+    requester.use(authErrors());
+    const sanityEnv = process.env.SANITY_INTERNAL_ENV || 'production';
+    const token = await getCliToken();
+    const apiHost = apiHosts[sanityEnv];
+    if (requireUser && !token) {
+        throw new Error('You must login first - run "sanity login"');
+    }
+    return createClient({
+        ...apiHost ? {
+            apiHost
+        } : {},
+        apiVersion,
+        requester,
+        requestTagPrefix: CLI_REQUEST_TAG_PREFIX,
+        token,
+        useCdn: false,
+        useProjectHostname: false
+    });
+}
+/**
+ * Create a "global" (unscoped) Sanity API client.
+ *
+ * @param options - The options to use for the client.
+ * @returns Promise that resolves to a configured Sanity API client.
+ */ export async function getProjectCliClient({ apiVersion, dataset, projectId, requireUser }) {
+    const requester = defaultRequester.clone();
+    requester.use(authErrors());
+    const sanityEnv = process.env.SANITY_INTERNAL_ENV || 'production';
+    const token = await getCliToken();
+    const apiHost = apiHosts[sanityEnv];
+    if (requireUser && !token) {
+        throw new Error('You must login first - run "sanity login"');
+    }
+    return createClient({
+        ...apiHost ? {
+            apiHost
+        } : {},
+        apiVersion,
+        dataset,
+        projectId,
+        requester,
+        requestTagPrefix: CLI_REQUEST_TAG_PREFIX,
+        token,
+        useCdn: false,
+        useProjectHostname: true
+    });
+}
+/**
+ * `get-it` middleware that checks for 401 authentication errors and extends the error with more
+ * helpful guidance on what to do next.
+ *
+ * @returns get-it middleware with `onError` handler
+ * @internal
+ */ function authErrors() {
+    return {
+        onError: (err)=>{
+            if (!err || !isReqResError(err)) {
+                return err;
+            }
+            const statusCode = isHttpError(err) && err.response.body.statusCode;
+            if (statusCode === 401) {
+                err.message = `${err.message}. You may need to login again with ${ux.colorize('cyan', 'sanity login')}.\nFor more information, see ${generateHelpUrl('cli-errors')}.`;
+            }
+            return err;
+        }
+    };
+}
+function isReqResError(err) {
+    return Object.prototype.hasOwnProperty.call(err, 'response');
+}
+
+//# sourceMappingURL=apiClient.js.map

package/dist/services/apiClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/services/apiClient.ts"],"sourcesContent":["import {ux} from '@oclif/core'\nimport {\n  type ClientError,\n  createClient,\n  requester as defaultRequester,\n  type SanityClient,\n  type ServerError,\n} from '@sanity/client'\n\nimport {generateHelpUrl} from '../util/generateHelpUrl.js'\nimport {isHttpError} from '../util/isHttpError.js'\nimport {getCliToken} from './getCliToken.js'\n\nconst apiHosts: Record<string, string | undefined> = {\n  staging: 'https://api.sanity.work',\n}\n\nconst CLI_REQUEST_TAG_PREFIX = 'sanity.cli'\n\n/**\n * @internal\n */\nexport interface GlobalCliClientOptions {\n  /**\n   * The API version to use for this client.\n   */\n  apiVersion: string\n\n  /**\n   * Whether to require a user to be authenticated to use this client.\n   * Default: `false`.\n   * Throws an error if `true` and user is not authenticated.\n   */\n  requireUser?: boolean\n}\n\n/**\n * Create a \"global\" (unscoped) Sanity API client.\n *\n * @param options - The options to use for the client.\n * @returns Promise that resolves to a configured Sanity API client.\n */\nexport async function getGlobalCliClient({\n  apiVersion,\n  requireUser,\n}: GlobalCliClientOptions): Promise<SanityClient> {\n  const requester = defaultRequester.clone()\n  requester.use(authErrors())\n\n  const sanityEnv = process.env.SANITY_INTERNAL_ENV || 'production'\n\n  const token = await getCliToken()\n  const apiHost = apiHosts[sanityEnv]\n\n  if (requireUser && !token) {\n    throw new Error('You must login first - run \"sanity login\"')\n  }\n\n  return createClient({\n    ...(apiHost ? {apiHost} : {}),\n    apiVersion,\n    requester,\n    requestTagPrefix: CLI_REQUEST_TAG_PREFIX,\n    token,\n    useCdn: false,\n    useProjectHostname: false,\n  })\n}\n\n/**\n * @internal\n */\nexport interface ProjectCliClientOptions {\n  apiVersion: string\n  projectId: string\n\n  dataset?: string\n\n  requireUser?: boolean\n}\n\n/**\n * Create a \"global\" (unscoped) Sanity API client.\n *\n * @param options - The options to use for the client.\n * @returns Promise that resolves to a configured Sanity API client.\n */\nexport async function getProjectCliClient({\n  apiVersion,\n  dataset,\n  projectId,\n  requireUser,\n}: ProjectCliClientOptions): Promise<SanityClient> {\n  const requester = defaultRequester.clone()\n  requester.use(authErrors())\n\n  const sanityEnv = process.env.SANITY_INTERNAL_ENV || 'production'\n\n  const token = await getCliToken()\n  const apiHost = apiHosts[sanityEnv]\n\n  if (requireUser && !token) {\n    throw new Error('You must login first - run \"sanity login\"')\n  }\n\n  return createClient({\n    ...(apiHost ? {apiHost} : {}),\n    apiVersion,\n    dataset,\n    projectId,\n    requester,\n    requestTagPrefix: CLI_REQUEST_TAG_PREFIX,\n    token,\n    useCdn: false,\n    useProjectHostname: true,\n  })\n}\n\n/**\n * `get-it` middleware that checks for 401 authentication errors and extends the error with more\n * helpful guidance on what to do next.\n *\n * @returns get-it middleware with `onError` handler\n * @internal\n */\nfunction authErrors() {\n  return {\n    onError: (err: Error | null) => {\n      if (!err || !isReqResError(err)) {\n        return err\n      }\n\n      const statusCode = isHttpError(err) && err.response.body.statusCode\n      if (statusCode === 401) {\n        err.message = `${err.message}. You may need to login again with ${ux.colorize('cyan', 'sanity login')}.\\nFor more information, see ${generateHelpUrl('cli-errors')}.`\n      }\n\n      return err\n    },\n  }\n}\n\nfunction isReqResError(err: Error): err is ClientError | ServerError {\n  return Object.prototype.hasOwnProperty.call(err, 'response')\n}\n"],"names":["ux","createClient","requester","defaultRequester","generateHelpUrl","isHttpError","getCliToken","apiHosts","staging","CLI_REQUEST_TAG_PREFIX","getGlobalCliClient","apiVersion","requireUser","clone","use","authErrors","sanityEnv","process","env","SANITY_INTERNAL_ENV","token","apiHost","Error","requestTagPrefix","useCdn","useProjectHostname","getProjectCliClient","dataset","projectId","onError","err","isReqResError","statusCode","response","body","message","colorize","Object","prototype","hasOwnProperty","call"],"mappings":"AAAA,SAAQA,EAAE,QAAO,cAAa;AAC9B,SAEEC,YAAY,EACZC,aAAaC,gBAAgB,QAGxB,iBAAgB;AAEvB,SAAQC,eAAe,QAAO,6BAA4B;AAC1D,SAAQC,WAAW,QAAO,yBAAwB;AAClD,SAAQC,WAAW,QAAO,mBAAkB;AAE5C,MAAMC,WAA+C;IACnDC,SAAS;AACX;AAEA,MAAMC,yBAAyB;AAmB/B;;;;;CAKC,GACD,OAAO,eAAeC,mBAAmB,EACvCC,UAAU,EACVC,WAAW,EACY;IACvB,MAAMV,YAAYC,iBAAiBU,KAAK;IACxCX,UAAUY,GAAG,CAACC;IAEd,MAAMC,YAAYC,QAAQC,GAAG,CAACC,mBAAmB,IAAI;IAErD,MAAMC,QAAQ,MAAMd;IACpB,MAAMe,UAAUd,QAAQ,CAACS,UAAU;IAEnC,IAAIJ,eAAe,CAACQ,OAAO;QACzB,MAAM,IAAIE,MAAM;IAClB;IAEA,OAAOrB,aAAa;QAClB,GAAIoB,UAAU;YAACA;QAAO,IAAI,CAAC,CAAC;QAC5BV;QACAT;QACAqB,kBAAkBd;QAClBW;QACAI,QAAQ;QACRC,oBAAoB;IACtB;AACF;AAcA;;;;;CAKC,GACD,OAAO,eAAeC,oBAAoB,EACxCf,UAAU,EACVgB,OAAO,EACPC,SAAS,EACThB,WAAW,EACa;IACxB,MAAMV,YAAYC,iBAAiBU,KAAK;IACxCX,UAAUY,GAAG,CAACC;IAEd,MAAMC,YAAYC,QAAQC,GAAG,CAACC,mBAAmB,IAAI;IAErD,MAAMC,QAAQ,MAAMd;IACpB,MAAMe,UAAUd,QAAQ,CAACS,UAAU;IAEnC,IAAIJ,eAAe,CAACQ,OAAO;QACzB,MAAM,IAAIE,MAAM;IAClB;IAEA,OAAOrB,aAAa;QAClB,GAAIoB,UAAU;YAACA;QAAO,IAAI,CAAC,CAAC;QAC5BV;QACAgB;QACAC;QACA1B;QACAqB,kBAAkBd;QAClBW;QACAI,QAAQ;QACRC,oBAAoB;IACtB;AACF;AAEA;;;;;;CAMC,GACD,SAASV;IACP,OAAO;QACLc,SAAS,CAACC;YACR,IAAI,CAACA,OAAO,CAACC,cAAcD,MAAM;gBAC/B,OAAOA;YACT;YAEA,MAAME,aAAa3B,YAAYyB,QAAQA,IAAIG,QAAQ,CAACC,IAAI,CAACF,UAAU;YACnE,IAAIA,eAAe,KAAK;gBACtBF,IAAIK,OAAO,GAAG,GAAGL,IAAIK,OAAO,CAAC,mCAAmC,EAAEnC,GAAGoC,QAAQ,CAAC,QAAQ,gBAAgB,6BAA6B,EAAEhC,gBAAgB,cAAc,CAAC,CAAC;YACvK;YAEA,OAAO0B;QACT;IACF;AACF;AAEA,SAASC,cAAcD,GAAU;IAC/B,OAAOO,OAAOC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACV,KAAK;AACnD"}

package/dist/services/cliUserConfig.d.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+declare const cliUserConfigSchema: {
+    authToken: z.ZodOptional<z.ZodString>;
+    telemetryConsent: z.ZodOptional<z.ZodObject<{
+        updatedAt: z.ZodOptional<z.ZodNumber>;
+        value: z.ZodObject<{
+            status: z.ZodEnum<["undetermined", "unset", "granted", "denied"]>;
+            type: z.ZodString;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            status: z.ZodEnum<["undetermined", "unset", "granted", "denied"]>;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            status: z.ZodEnum<["undetermined", "unset", "granted", "denied"]>;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">>;
+    }, "strip", z.ZodTypeAny, {
+        value: {
+            type: string;
+            status: "undetermined" | "unset" | "granted" | "denied";
+        } & {
+            [k: string]: unknown;
+        };
+        updatedAt?: number | undefined;
+    }, {
+        value: {
+            type: string;
+            status: "undetermined" | "unset" | "granted" | "denied";
+        } & {
+            [k: string]: unknown;
+        };
+        updatedAt?: number | undefined;
+    }>>;
+};
+/**
+ * The CLI user configuration schema.
+ *
+ * @internal
+ */
+type CliUserConfig = z.infer<z.ZodObject<typeof cliUserConfigSchema>>;
+/**
+ * Set the config value for the given property.
+ * Validates that the passed value adheres to the defined CLI config schema.
+ *
+ * @param prop - The property to set the value for
+ * @param value - The value to set
+ * @internal
+ */
+export declare function setConfig<P extends keyof CliUserConfig>(prop: P, value: CliUserConfig[P]): Promise<void>;
+/**
+ * Get the config value for the given property
+ *
+ * @param prop - The property to get the value for
+ * @returns The value of the given property
+ * @internal
+ */
+export declare function getConfig<P extends keyof CliUserConfig>(prop: P): Promise<CliUserConfig[P]>;
+export {};