@sanity/codegen 5.7.0-next.8 → 5.7.0

package/dist/typescript/findQueriesInSource.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/typescript/findQueriesInSource.ts"],"sourcesContent":["import {createRequire} from 'node:module'\n\nimport {type NodePath, type TransformOptions, traverse} from '@babel/core'\nimport {type Scope} from '@babel/traverse'\nimport * as babelTypes from '@babel/types'\n\nimport {getBabelConfig} from '../getBabelConfig.js'\nimport {resolveExpression} from './expressionResolvers.js'\nimport {parseSourceFile} from './parseSource.js'\nimport {type ExtractedModule, type ExtractedQuery, QueryExtractionError} from './types.js'\n\nconst require = createRequire(import.meta.url)\n\nconst groqTagName = 'groq'\nconst defineQueryFunctionName = 'defineQuery'\nconst groqModuleName = 'groq'\nconst nextSanityModuleName = 'next-sanity'\nconst sveltekitModuleName = '@sanity/sveltekit'\n\nconst ignoreValue = '@sanity-typegen-ignore'\n\n/**\n * findQueriesInSource takes a source string and returns all GROQ queries in it.\n * @param source - The source code to search for queries\n * @param filename - The filename of the source code\n * @param babelConfig - The babel configuration to use when parsing the source\n * @param resolver - A resolver function to use when resolving module imports\n * @returns\n * @beta\n * @internal\n */\nexport function findQueriesInSource(\n  source: string,\n  filename: string,\n  babelConfig: TransformOptions = getBabelConfig(),\n  resolver: NodeJS.RequireResolve = require.resolve,\n): ExtractedModule {\n  const queries: ExtractedQuery[] = []\n  const errors: QueryExtractionError[] = []\n  const file = parseSourceFile(source, filename, babelConfig)\n\n  traverse(file, {\n    // Look for variable declarations, e.g. `const myQuery = groq`... and extract the query.\n    // The variable name is used as the name of the query result type\n    VariableDeclarator(path) {\n      const {node, scope} = path\n\n      const init = node.init\n\n      // Look for tagged template expressions that are called with the `groq` tag\n      const isGroqTemplateTag =\n        babelTypes.isTaggedTemplateExpression(init) &&\n        babelTypes.isIdentifier(init.tag) &&\n        init.tag.name === groqTagName\n\n      // Look for strings wrapped in a defineQuery function call\n      const isDefineQueryCall =\n        babelTypes.isCallExpression(init) &&\n        (isImportFrom(groqModuleName, defineQueryFunctionName, scope, init.callee) ||\n          isImportFrom(nextSanityModuleName, defineQueryFunctionName, scope, init.callee) ||\n          isImportFrom(sveltekitModuleName, defineQueryFunctionName, scope, init.callee))\n\n      if (babelTypes.isIdentifier(node.id) && (isGroqTemplateTag || isDefineQueryCall)) {\n        // If we find a comment leading the decleration which macthes with ignoreValue we don't add\n        // the query\n        if (declarationLeadingCommentContains(path, ignoreValue)) {\n          return\n        }\n\n        const {end, id, start} = node\n        const variable = {id, ...(start && {start}), ...(end && {end})}\n\n        try {\n          const query = resolveExpression({\n            babelConfig,\n            file,\n            filename,\n            node: init,\n            resolver,\n            scope,\n          })\n          queries.push({filename, query, variable})\n        } catch (cause) {\n          errors.push(new QueryExtractionError({cause, filename, variable}))\n        }\n      }\n    },\n  })\n\n  return {errors, filename, queries}\n}\n\nfunction declarationLeadingCommentContains(path: NodePath, comment: string): boolean {\n  /*\n   * We have to consider these cases:\n   *\n   * // @sanity-typegen-ignore\n   * const query = groq`...`\n   *\n   * // AST\n   * VariableDeclaration {\n   *   declarations: [\n   *     VariableDeclarator: {init: tag: {name: \"groq\"}}\n   *   ],\n   *   leadingComments: ...\n   * }\n   *\n   * // @sanity-typegen-ignore\n   * const query1 = groq`...`, query2 = groq`...`\n   *\n   * // AST\n   * VariableDeclaration {\n   *   declarations: [\n   *     VariableDeclarator: {init: tag: {name: \"groq\"}}\n   *     VariableDeclarator: {init: tag: {name: \"groq\"}}\n   *   ],\n   *   leadingComments: ...\n   * }\n   *\n   * // @sanity-typegen-ignore\n   * export const query = groq`...`\n   *\n   * // AST\n   * ExportNamedDeclaration {\n   *   declaration: VariableDeclaration {\n   *     declarations: [\n   *       VariableDeclarator: {init: tag: {name: \"groq\"}}\n   *       VariableDeclarator: {init: tag: {name: \"groq\"}}\n   *     ],\n   *   },\n   *   leadingComments: ...\n   * }\n   *\n   * In the case where multiple variables are under the same VariableDeclaration the leadingComments\n   * will still be on the VariableDeclaration\n   *\n   * In the case where the variable is exported, the leadingComments are on the\n   * ExportNamedDeclaration which includes the VariableDeclaration in its own declaration property\n   */\n\n  const variableDeclaration = path.find((node) => node.isVariableDeclaration())\n  if (!variableDeclaration) return false\n\n  if (\n    variableDeclaration.node.leadingComments?.find(\n      (commentItem) => commentItem.value.trim() === comment,\n    )\n  ) {\n    return true\n  }\n\n  // If the declaration is exported, the comment lies on the parent of the export declaration\n  if (\n    variableDeclaration.parent.leadingComments?.find(\n      (commentItem) => commentItem.value.trim() === comment,\n    )\n  ) {\n    return true\n  }\n\n  return false\n}\n\nfunction isImportFrom(\n  moduleName: string,\n  importName: string,\n  scope: Scope,\n  node: babelTypes.Expression | babelTypes.V8IntrinsicIdentifier,\n) {\n  if (babelTypes.isIdentifier(node)) {\n    const binding = scope.getBinding(node.name)\n    if (!binding) {\n      return false\n    }\n\n    const {path} = binding\n\n    // import { foo } from 'groq'\n    if (babelTypes.isImportSpecifier(path.node)) {\n      return (\n        path.node.importKind === 'value' &&\n        path.parentPath &&\n        babelTypes.isImportDeclaration(path.parentPath.node) &&\n        path.parentPath.node.source.value === moduleName &&\n        babelTypes.isIdentifier(path.node.imported) &&\n        path.node.imported.name === importName\n      )\n    }\n\n    // const { defineQuery } = require('groq')\n    if (babelTypes.isVariableDeclarator(path.node)) {\n      const {init} = path.node\n      return (\n        babelTypes.isCallExpression(init) &&\n        babelTypes.isIdentifier(init.callee) &&\n        init.callee.name === 'require' &&\n        babelTypes.isStringLiteral(init.arguments[0]) &&\n        init.arguments[0].value === moduleName\n      )\n    }\n  }\n\n  // import * as foo from 'groq'\n  // foo.defineQuery(...)\n  if (babelTypes.isMemberExpression(node)) {\n    const {object, property} = node\n\n    if (!babelTypes.isIdentifier(object)) {\n      return false\n    }\n\n    const binding = scope.getBinding(object.name)\n    if (!binding) {\n      return false\n    }\n    const {path} = binding\n\n    return (\n      babelTypes.isIdentifier(object) &&\n      babelTypes.isIdentifier(property) &&\n      property.name === importName &&\n      babelTypes.isImportNamespaceSpecifier(path.node) &&\n      path.parentPath &&\n      babelTypes.isImportDeclaration(path.parentPath.node) &&\n      path.parentPath.node.source.value === moduleName\n    )\n  }\n\n  return false\n}\n"],"names":["createRequire","traverse","babelTypes","getBabelConfig","resolveExpression","parseSourceFile","QueryExtractionError","require","url","groqTagName","defineQueryFunctionName","groqModuleName","nextSanityModuleName","sveltekitModuleName","ignoreValue","findQueriesInSource","source","filename","babelConfig","resolver","resolve","queries","errors","file","VariableDeclarator","path","node","scope","init","isGroqTemplateTag","isTaggedTemplateExpression","isIdentifier","tag","name","isDefineQueryCall","isCallExpression","isImportFrom","callee","id","declarationLeadingCommentContains","end","start","variable","query","push","cause","comment","variableDeclaration","find","isVariableDeclaration","leadingComments","commentItem","value","trim","parent","moduleName","importName","binding","getBinding","isImportSpecifier","importKind","parentPath","isImportDeclaration","imported","isVariableDeclarator","isStringLiteral","arguments","isMemberExpression","object","property","isImportNamespaceSpecifier"],"mappings":"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"}

package/dist/typescript/helpers.js

@@ -0,0 +1,86 @@
+import path from 'node:path';
+import { CodeGenerator } from '@babel/generator';
+import * as t from '@babel/types';
+import { formatPath } from '../utils/formatPath.js';
+import { RESERVED_IDENTIFIERS } from './constants.js';
+export function normalizePrintablePath(root, filename) {
+    const resolved = path.resolve(root, filename);
+    // Always use Unix-style paths for consistent output across platforms
+    return formatPath(path.relative(root, resolved));
+}
+/**
+ * Normalizes a glob pattern to use forward slashes (POSIX-style paths).
+ * Glob patterns must use forward slashes, even on Windows.
+ *
+ * @param pattern - A glob pattern string or array of patterns
+ * @returns The normalized pattern(s) with forward slashes
+ * @see https://github.com/sindresorhus/globby#api
+ */ export function normalizeGlobPattern(pattern) {
+    if (Array.isArray(pattern)) {
+        return pattern.map((p)=>formatPath(p));
+    }
+    return formatPath(pattern);
+}
+function sanitizeIdentifier(input) {
+    return `${input.replace(/^\d/, '_').replaceAll(/[^$\w]+(.)/g, (_, char)=>char.toUpperCase())}`;
+}
+/**
+ * Checks if a string is a valid ECMAScript IdentifierName.
+ * IdentifierNames start with a letter, underscore, or $, and contain only
+ * alphanumeric characters, underscores, or $.
+ */ export function isIdentifierName(input) {
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(input);
+}
+function normalizeIdentifier(input) {
+    const sanitized = sanitizeIdentifier(input);
+    return `${sanitized.charAt(0).toUpperCase()}${sanitized.slice(1)}`;
+}
+export function getUniqueIdentifierForName(name, currentIdentifiers) {
+    const desiredName = normalizeIdentifier(name);
+    let resultingName = desiredName;
+    let index = 2;
+    while(currentIdentifiers.has(resultingName) || RESERVED_IDENTIFIERS.has(resultingName)){
+        resultingName = `${desiredName}_${index}`;
+        index++;
+    }
+    return t.identifier(resultingName);
+}
+export function computeOnce(fn) {
+    const ref = {
+        computed: false,
+        current: undefined
+    };
+    return function() {
+        if (ref.computed) return ref.current;
+        ref.current = fn();
+        ref.computed = true;
+        return ref.current;
+    };
+}
+export function weakMapMemo(fn) {
+    const cache = new WeakMap();
+    const wrapped = function(arg) {
+        if (cache.has(arg)) return cache.get(arg);
+        const result = fn(arg);
+        cache.set(arg, result);
+        return result;
+    };
+    return wrapped;
+}
+export function generateCode(node) {
+    return `${new CodeGenerator(node).generate().code.trim()}\n\n`;
+}
+export function getFilterArrayUnionType(typeNode, predicate) {
+    if (typeNode.of.type !== 'union') {
+        return typeNode;
+    }
+    return {
+        ...typeNode,
+        of: {
+            ...typeNode.of,
+            of: typeNode.of.of.filter((unionTypeNode)=>predicate(unionTypeNode))
+        }
+    };
+}
+
+//# sourceMappingURL=helpers.js.map

package/dist/typescript/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/typescript/helpers.ts"],"sourcesContent":["import path from 'node:path'\n\nimport {CodeGenerator} from '@babel/generator'\nimport * as t from '@babel/types'\nimport {type ArrayTypeNode, type UnionTypeNode} from 'groq-js'\n\nimport {formatPath} from '../utils/formatPath.js'\nimport {RESERVED_IDENTIFIERS} from './constants.js'\n\nexport function normalizePrintablePath(root: string, filename: string) {\n  const resolved = path.resolve(root, filename)\n  // Always use Unix-style paths for consistent output across platforms\n  return formatPath(path.relative(root, resolved))\n}\n\n/**\n * Normalizes a glob pattern to use forward slashes (POSIX-style paths).\n * Glob patterns must use forward slashes, even on Windows.\n *\n * @param pattern - A glob pattern string or array of patterns\n * @returns The normalized pattern(s) with forward slashes\n * @see https://github.com/sindresorhus/globby#api\n */\nexport function normalizeGlobPattern(pattern: string | string[]): string | string[] {\n  if (Array.isArray(pattern)) {\n    return pattern.map((p) => formatPath(p))\n  }\n  return formatPath(pattern)\n}\n\nfunction sanitizeIdentifier(input: string): string {\n  return `${input.replace(/^\\d/, '_').replaceAll(/[^$\\w]+(.)/g, (_, char) => char.toUpperCase())}`\n}\n\n/**\n * Checks if a string is a valid ECMAScript IdentifierName.\n * IdentifierNames start with a letter, underscore, or $, and contain only\n * alphanumeric characters, underscores, or $.\n */\nexport function isIdentifierName(input: string): boolean {\n  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(input)\n}\n\nfunction normalizeIdentifier(input: string): string {\n  const sanitized = sanitizeIdentifier(input)\n  return `${sanitized.charAt(0).toUpperCase()}${sanitized.slice(1)}`\n}\n\nexport function getUniqueIdentifierForName(name: string, currentIdentifiers: Set<string>) {\n  const desiredName = normalizeIdentifier(name)\n  let resultingName = desiredName\n  let index = 2\n  while (currentIdentifiers.has(resultingName) || RESERVED_IDENTIFIERS.has(resultingName)) {\n    resultingName = `${desiredName}_${index}`\n    index++\n  }\n  return t.identifier(resultingName)\n}\n\nexport function computeOnce<TReturn>(fn: () => TReturn): () => TReturn {\n  const ref = {computed: false, current: undefined as TReturn | undefined}\n\n  return function () {\n    if (ref.computed) return ref.current as TReturn\n    ref.current = fn()\n    ref.computed = true\n    return ref.current\n  }\n}\n\nexport function weakMapMemo<TParam extends object, TReturn>(fn: (arg: TParam) => TReturn) {\n  const cache = new WeakMap<object, TReturn>()\n\n  const wrapped = function (arg: TParam) {\n    if (cache.has(arg)) return cache.get(arg)!\n    const result = fn(arg)\n    cache.set(arg, result)\n    return result\n  }\n\n  return wrapped\n}\n\nexport function generateCode(node: t.Node) {\n  return `${new CodeGenerator(node).generate().code.trim()}\\n\\n`\n}\n\nexport function getFilterArrayUnionType(\n  typeNode: ArrayTypeNode,\n  predicate: (unionTypeNode: UnionTypeNode['of'][number]) => boolean,\n): ArrayTypeNode {\n  if (typeNode.of.type !== 'union') {\n    return typeNode\n  }\n\n  return {\n    ...typeNode,\n    of: {\n      ...typeNode.of,\n      of: typeNode.of.of.filter((unionTypeNode) => predicate(unionTypeNode)),\n    },\n  } satisfies ArrayTypeNode<UnionTypeNode>\n}\n"],"names":["path","CodeGenerator","t","formatPath","RESERVED_IDENTIFIERS","normalizePrintablePath","root","filename","resolved","resolve","relative","normalizeGlobPattern","pattern","Array","isArray","map","p","sanitizeIdentifier","input","replace","replaceAll","_","char","toUpperCase","isIdentifierName","test","normalizeIdentifier","sanitized","charAt","slice","getUniqueIdentifierForName","name","currentIdentifiers","desiredName","resultingName","index","has","identifier","computeOnce","fn","ref","computed","current","undefined","weakMapMemo","cache","WeakMap","wrapped","arg","get","result","set","generateCode","node","generate","code","trim","getFilterArrayUnionType","typeNode","predicate","of","type","filter","unionTypeNode"],"mappings":"AAAA,OAAOA,UAAU,YAAW;AAE5B,SAAQC,aAAa,QAAO,mBAAkB;AAC9C,YAAYC,OAAO,eAAc;AAGjC,SAAQC,UAAU,QAAO,yBAAwB;AACjD,SAAQC,oBAAoB,QAAO,iBAAgB;AAEnD,OAAO,SAASC,uBAAuBC,IAAY,EAAEC,QAAgB;IACnE,MAAMC,WAAWR,KAAKS,OAAO,CAACH,MAAMC;IACpC,qEAAqE;IACrE,OAAOJ,WAAWH,KAAKU,QAAQ,CAACJ,MAAME;AACxC;AAEA;;;;;;;CAOC,GACD,OAAO,SAASG,qBAAqBC,OAA0B;IAC7D,IAAIC,MAAMC,OAAO,CAACF,UAAU;QAC1B,OAAOA,QAAQG,GAAG,CAAC,CAACC,IAAMb,WAAWa;IACvC;IACA,OAAOb,WAAWS;AACpB;AAEA,SAASK,mBAAmBC,KAAa;IACvC,OAAO,GAAGA,MAAMC,OAAO,CAAC,OAAO,KAAKC,UAAU,CAAC,eAAe,CAACC,GAAGC,OAASA,KAAKC,WAAW,KAAK;AAClG;AAEA;;;;CAIC,GACD,OAAO,SAASC,iBAAiBN,KAAa;IAC5C,OAAO,6BAA6BO,IAAI,CAACP;AAC3C;AAEA,SAASQ,oBAAoBR,KAAa;IACxC,MAAMS,YAAYV,mBAAmBC;IACrC,OAAO,GAAGS,UAAUC,MAAM,CAAC,GAAGL,WAAW,KAAKI,UAAUE,KAAK,CAAC,IAAI;AACpE;AAEA,OAAO,SAASC,2BAA2BC,IAAY,EAAEC,kBAA+B;IACtF,MAAMC,cAAcP,oBAAoBK;IACxC,IAAIG,gBAAgBD;IACpB,IAAIE,QAAQ;IACZ,MAAOH,mBAAmBI,GAAG,CAACF,kBAAkB9B,qBAAqBgC,GAAG,CAACF,eAAgB;QACvFA,gBAAgB,GAAGD,YAAY,CAAC,EAAEE,OAAO;QACzCA;IACF;IACA,OAAOjC,EAAEmC,UAAU,CAACH;AACtB;AAEA,OAAO,SAASI,YAAqBC,EAAiB;IACpD,MAAMC,MAAM;QAACC,UAAU;QAAOC,SAASC;IAAgC;IAEvE,OAAO;QACL,IAAIH,IAAIC,QAAQ,EAAE,OAAOD,IAAIE,OAAO;QACpCF,IAAIE,OAAO,GAAGH;QACdC,IAAIC,QAAQ,GAAG;QACf,OAAOD,IAAIE,OAAO;IACpB;AACF;AAEA,OAAO,SAASE,YAA4CL,EAA4B;IACtF,MAAMM,QAAQ,IAAIC;IAElB,MAAMC,UAAU,SAAUC,GAAW;QACnC,IAAIH,MAAMT,GAAG,CAACY,MAAM,OAAOH,MAAMI,GAAG,CAACD;QACrC,MAAME,SAASX,GAAGS;QAClBH,MAAMM,GAAG,CAACH,KAAKE;QACf,OAAOA;IACT;IAEA,OAAOH;AACT;AAEA,OAAO,SAASK,aAAaC,IAAY;IACvC,OAAO,GAAG,IAAIpD,cAAcoD,MAAMC,QAAQ,GAAGC,IAAI,CAACC,IAAI,GAAG,IAAI,CAAC;AAChE;AAEA,OAAO,SAASC,wBACdC,QAAuB,EACvBC,SAAkE;IAElE,IAAID,SAASE,EAAE,CAACC,IAAI,KAAK,SAAS;QAChC,OAAOH;IACT;IAEA,OAAO;QACL,GAAGA,QAAQ;QACXE,IAAI;YACF,GAAGF,SAASE,EAAE;YACdA,IAAIF,SAASE,EAAE,CAACA,EAAE,CAACE,MAAM,CAAC,CAACC,gBAAkBJ,UAAUI;QACzD;IACF;AACF"}

package/dist/typescript/moduleResolver.js

@@ -0,0 +1,33 @@
+import { createRequire } from 'node:module';
+import createDebug from 'debug';
+import { createMatchPath, loadConfig as loadTSConfig } from 'tsconfig-paths';
+const require = createRequire(import.meta.url);
+const debug = createDebug('sanity:codegen:moduleResolver');
+/**
+ * This is a custom implementation of require.resolve that takes into account the paths
+ * configuration in tsconfig.json. This is necessary if we want to resolve paths that are
+ * custom defined in the tsconfig.json file.
+ * Resolving here is best effort and might not work in all cases.
+ * @beta
+ */ export function getResolver(cwd) {
+    const tsConfig = loadTSConfig(cwd);
+    if (tsConfig.resultType === 'failed') {
+        debug('Could not load tsconfig, using default resolver: %s', tsConfig.message);
+        return require.resolve;
+    }
+    const matchPath = createMatchPath(tsConfig.absoluteBaseUrl, tsConfig.paths, tsConfig.mainFields, tsConfig.addMatchAll);
+    const resolve = function(request, options) {
+        const found = matchPath(request);
+        if (found !== undefined) {
+            return require.resolve(found, options);
+        }
+        return require.resolve(request, options);
+    };
+    // wrap the resolve.path function to make it available.
+    resolve.paths = (request)=>{
+        return require.resolve.paths(request);
+    };
+    return resolve;
+}
+
+//# sourceMappingURL=moduleResolver.js.map

package/dist/typescript/moduleResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/typescript/moduleResolver.ts"],"sourcesContent":["import {createRequire} from 'node:module'\n\nimport createDebug from 'debug'\nimport {createMatchPath, loadConfig as loadTSConfig} from 'tsconfig-paths'\n\nconst require = createRequire(import.meta.url)\nconst debug = createDebug('sanity:codegen:moduleResolver')\n\n/**\n * This is a custom implementation of require.resolve that takes into account the paths\n * configuration in tsconfig.json. This is necessary if we want to resolve paths that are\n * custom defined in the tsconfig.json file.\n * Resolving here is best effort and might not work in all cases.\n * @beta\n */\nexport function getResolver(cwd?: string): NodeJS.RequireResolve {\n  const tsConfig = loadTSConfig(cwd)\n\n  if (tsConfig.resultType === 'failed') {\n    debug('Could not load tsconfig, using default resolver: %s', tsConfig.message)\n    return require.resolve\n  }\n\n  const matchPath = createMatchPath(\n    tsConfig.absoluteBaseUrl,\n    tsConfig.paths,\n    tsConfig.mainFields,\n    tsConfig.addMatchAll,\n  )\n\n  const resolve = function (request: string, options?: {paths?: string[]}): string {\n    const found = matchPath(request)\n    if (found !== undefined) {\n      return require.resolve(found, options)\n    }\n    return require.resolve(request, options)\n  }\n\n  // wrap the resolve.path function to make it available.\n  resolve.paths = (request: string): string[] | null => {\n    return require.resolve.paths(request)\n  }\n  return resolve\n}\n"],"names":["createRequire","createDebug","createMatchPath","loadConfig","loadTSConfig","require","url","debug","getResolver","cwd","tsConfig","resultType","message","resolve","matchPath","absoluteBaseUrl","paths","mainFields","addMatchAll","request","options","found","undefined"],"mappings":"AAAA,SAAQA,aAAa,QAAO,cAAa;AAEzC,OAAOC,iBAAiB,QAAO;AAC/B,SAAQC,eAAe,EAAEC,cAAcC,YAAY,QAAO,iBAAgB;AAE1E,MAAMC,UAAUL,cAAc,YAAYM,GAAG;AAC7C,MAAMC,QAAQN,YAAY;AAE1B;;;;;;CAMC,GACD,OAAO,SAASO,YAAYC,GAAY;IACtC,MAAMC,WAAWN,aAAaK;IAE9B,IAAIC,SAASC,UAAU,KAAK,UAAU;QACpCJ,MAAM,uDAAuDG,SAASE,OAAO;QAC7E,OAAOP,QAAQQ,OAAO;IACxB;IAEA,MAAMC,YAAYZ,gBAChBQ,SAASK,eAAe,EACxBL,SAASM,KAAK,EACdN,SAASO,UAAU,EACnBP,SAASQ,WAAW;IAGtB,MAAML,UAAU,SAAUM,OAAe,EAAEC,OAA4B;QACrE,MAAMC,QAAQP,UAAUK;QACxB,IAAIE,UAAUC,WAAW;YACvB,OAAOjB,QAAQQ,OAAO,CAACQ,OAAOD;QAChC;QACA,OAAOf,QAAQQ,OAAO,CAACM,SAASC;IAClC;IAEA,uDAAuD;IACvDP,QAAQG,KAAK,GAAG,CAACG;QACf,OAAOd,QAAQQ,OAAO,CAACG,KAAK,CAACG;IAC/B;IACA,OAAON;AACT"}

package/dist/typescript/parseSource.js

@@ -0,0 +1,75 @@
+import { parse } from '@babel/core';
+// helper function to parse a source file
+export function parseSourceFile(_source, _filename, babelOptions) {
+    let source = _source;
+    let filename = _filename;
+    if (filename.endsWith('.astro')) {
+        // append .ts to the filename so babel will parse it as typescript
+        filename += '.ts';
+        source = parseAstro(source);
+    } else if (filename.endsWith('.vue')) {
+        // append .ts to the filename so babel will parse it as typescript
+        filename += '.ts';
+        source = parseVue(source);
+    } else if (filename.endsWith('.svelte')) {
+        // append .ts to the filename so babel will parse it as typescript
+        filename += '.ts';
+        source = parseSvelte(source);
+    }
+    const result = parse(source, {
+        ...babelOptions,
+        filename
+    });
+    if (!result) {
+        throw new Error(`Failed to parse ${filename}`);
+    }
+    return result;
+}
+function parseAstro(source) {
+    // find all code fences, the js code is between --- and ---
+    // Handle both Unix (\n) and Windows (\r\n) line endings
+    const codeFences = source.match(/---\r?\n([\s\S]*?)\r?\n---/g);
+    if (!codeFences) {
+        return '';
+    }
+    return codeFences.map((codeFence)=>{
+        // Split on either \n or \r\n
+        return codeFence.split(/\r?\n/).slice(1, -1).join('\n');
+    }).join('\n');
+}
+function parseVue(source) {
+    // find all script tags, the js code is between <script> and </script>
+    const scriptRegex = /<script(?:\s+generic=["'][^"']*["'])?[^>]*>([\s\S]*?)<\/script>/g;
+    // const matches = [...source.matchAll(scriptRegex)]
+    // TODO: swap once this code runs in `ES2020`
+    const matches = matchAllPolyfill(source, scriptRegex);
+    if (matches.length === 0) {
+        return '';
+    }
+    return matches.map((match)=>match[1]).join('\n');
+}
+function parseSvelte(source) {
+    // find all script tags, the js code is between <script> and </script>
+    const scriptRegex = /<script[^>]*>([\s\S]*?)<\/script>/g;
+    // const matches = [...source.matchAll(scriptRegex)]
+    // TODO: swap once this code runs in `ES2020`
+    const matches = matchAllPolyfill(source, scriptRegex);
+    if (matches.length === 0) {
+        return '';
+    }
+    return matches.map((match)=>match[1]).join('\n');
+}
+// TODO: remove once this code runs in `ES2020`
+function matchAllPolyfill(str, regex) {
+    if (!regex.global) {
+        throw new Error('matchAll polyfill requires a global regex (with /g flag)');
+    }
+    const matches = [];
+    let match;
+    while((match = regex.exec(str)) !== null){
+        matches.push(match);
+    }
+    return matches;
+}
+
+//# sourceMappingURL=parseSource.js.map

package/dist/typescript/parseSource.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/typescript/parseSource.ts"],"sourcesContent":["import type * as babelTypes from '@babel/types'\n\nimport {parse, type TransformOptions} from '@babel/core'\n\n// helper function to parse a source file\nexport function parseSourceFile(\n  _source: string,\n  _filename: string,\n  babelOptions: TransformOptions,\n): babelTypes.File {\n  let source = _source\n  let filename = _filename\n  if (filename.endsWith('.astro')) {\n    // append .ts to the filename so babel will parse it as typescript\n    filename += '.ts'\n    source = parseAstro(source)\n  } else if (filename.endsWith('.vue')) {\n    // append .ts to the filename so babel will parse it as typescript\n    filename += '.ts'\n    source = parseVue(source)\n  } else if (filename.endsWith('.svelte')) {\n    // append .ts to the filename so babel will parse it as typescript\n    filename += '.ts'\n    source = parseSvelte(source)\n  }\n  const result = parse(source, {\n    ...babelOptions,\n    filename,\n  })\n\n  if (!result) {\n    throw new Error(`Failed to parse ${filename}`)\n  }\n\n  return result\n}\n\nfunction parseAstro(source: string): string {\n  // find all code fences, the js code is between --- and ---\n  // Handle both Unix (\\n) and Windows (\\r\\n) line endings\n  const codeFences = source.match(/---\\r?\\n([\\s\\S]*?)\\r?\\n---/g)\n  if (!codeFences) {\n    return ''\n  }\n\n  return codeFences\n    .map((codeFence) => {\n      // Split on either \\n or \\r\\n\n      return codeFence.split(/\\r?\\n/).slice(1, -1).join('\\n')\n    })\n    .join('\\n')\n}\n\nfunction parseVue(source: string): string {\n  // find all script tags, the js code is between <script> and </script>\n  const scriptRegex = /<script(?:\\s+generic=[\"'][^\"']*[\"'])?[^>]*>([\\s\\S]*?)<\\/script>/g\n  // const matches = [...source.matchAll(scriptRegex)]\n  // TODO: swap once this code runs in `ES2020`\n  const matches = matchAllPolyfill(source, scriptRegex)\n  if (matches.length === 0) {\n    return ''\n  }\n\n  return matches.map((match) => match[1]).join('\\n')\n}\n\nfunction parseSvelte(source: string): string {\n  // find all script tags, the js code is between <script> and </script>\n  const scriptRegex = /<script[^>]*>([\\s\\S]*?)<\\/script>/g\n  // const matches = [...source.matchAll(scriptRegex)]\n  // TODO: swap once this code runs in `ES2020`\n  const matches = matchAllPolyfill(source, scriptRegex)\n  if (matches.length === 0) {\n    return ''\n  }\n\n  return matches.map((match) => match[1]).join('\\n')\n}\n\n// TODO: remove once this code runs in `ES2020`\nfunction matchAllPolyfill(str: string, regex: RegExp): RegExpMatchArray[] {\n  if (!regex.global) {\n    throw new Error('matchAll polyfill requires a global regex (with /g flag)')\n  }\n\n  const matches = []\n  let match\n  while ((match = regex.exec(str)) !== null) {\n    matches.push(match)\n  }\n  return matches\n}\n"],"names":["parse","parseSourceFile","_source","_filename","babelOptions","source","filename","endsWith","parseAstro","parseVue","parseSvelte","result","Error","codeFences","match","map","codeFence","split","slice","join","scriptRegex","matches","matchAllPolyfill","length","str","regex","global","exec","push"],"mappings":"AAEA,SAAQA,KAAK,QAA8B,cAAa;AAExD,yCAAyC;AACzC,OAAO,SAASC,gBACdC,OAAe,EACfC,SAAiB,EACjBC,YAA8B;IAE9B,IAAIC,SAASH;IACb,IAAII,WAAWH;IACf,IAAIG,SAASC,QAAQ,CAAC,WAAW;QAC/B,kEAAkE;QAClED,YAAY;QACZD,SAASG,WAAWH;IACtB,OAAO,IAAIC,SAASC,QAAQ,CAAC,SAAS;QACpC,kEAAkE;QAClED,YAAY;QACZD,SAASI,SAASJ;IACpB,OAAO,IAAIC,SAASC,QAAQ,CAAC,YAAY;QACvC,kEAAkE;QAClED,YAAY;QACZD,SAASK,YAAYL;IACvB;IACA,MAAMM,SAASX,MAAMK,QAAQ;QAC3B,GAAGD,YAAY;QACfE;IACF;IAEA,IAAI,CAACK,QAAQ;QACX,MAAM,IAAIC,MAAM,CAAC,gBAAgB,EAAEN,UAAU;IAC/C;IAEA,OAAOK;AACT;AAEA,SAASH,WAAWH,MAAc;IAChC,2DAA2D;IAC3D,wDAAwD;IACxD,MAAMQ,aAAaR,OAAOS,KAAK,CAAC;IAChC,IAAI,CAACD,YAAY;QACf,OAAO;IACT;IAEA,OAAOA,WACJE,GAAG,CAAC,CAACC;QACJ,6BAA6B;QAC7B,OAAOA,UAAUC,KAAK,CAAC,SAASC,KAAK,CAAC,GAAG,CAAC,GAAGC,IAAI,CAAC;IACpD,GACCA,IAAI,CAAC;AACV;AAEA,SAASV,SAASJ,MAAc;IAC9B,sEAAsE;IACtE,MAAMe,cAAc;IACpB,oDAAoD;IACpD,6CAA6C;IAC7C,MAAMC,UAAUC,iBAAiBjB,QAAQe;IACzC,IAAIC,QAAQE,MAAM,KAAK,GAAG;QACxB,OAAO;IACT;IAEA,OAAOF,QAAQN,GAAG,CAAC,CAACD,QAAUA,KAAK,CAAC,EAAE,EAAEK,IAAI,CAAC;AAC/C;AAEA,SAAST,YAAYL,MAAc;IACjC,sEAAsE;IACtE,MAAMe,cAAc;IACpB,oDAAoD;IACpD,6CAA6C;IAC7C,MAAMC,UAAUC,iBAAiBjB,QAAQe;IACzC,IAAIC,QAAQE,MAAM,KAAK,GAAG;QACxB,OAAO;IACT;IAEA,OAAOF,QAAQN,GAAG,CAAC,CAACD,QAAUA,KAAK,CAAC,EAAE,EAAEK,IAAI,CAAC;AAC/C;AAEA,+CAA+C;AAC/C,SAASG,iBAAiBE,GAAW,EAAEC,KAAa;IAClD,IAAI,CAACA,MAAMC,MAAM,EAAE;QACjB,MAAM,IAAId,MAAM;IAClB;IAEA,MAAMS,UAAU,EAAE;IAClB,IAAIP;IACJ,MAAO,AAACA,CAAAA,QAAQW,MAAME,IAAI,CAACH,IAAG,MAAO,KAAM;QACzCH,QAAQO,IAAI,CAACd;IACf;IACA,OAAOO;AACT"}

package/dist/typescript/registerBabel.js

@@ -0,0 +1,23 @@
+import register from '@babel/register';
+import { getBabelConfig } from '../getBabelConfig.js';
+/**
+ * Register Babel with the given options
+ *
+ * @param babelOptions - The options to use when registering Babel
+ * @beta
+ */ export function registerBabel(babelOptions) {
+    const options = babelOptions || getBabelConfig();
+    register({
+        ...options,
+        extensions: [
+            '.ts',
+            '.tsx',
+            '.js',
+            '.jsx',
+            '.mjs',
+            '.cjs'
+        ]
+    });
+}
+
+//# sourceMappingURL=registerBabel.js.map

package/dist/typescript/registerBabel.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/typescript/registerBabel.ts"],"sourcesContent":["import {type TransformOptions} from '@babel/core'\nimport register from '@babel/register'\n\nimport {getBabelConfig} from '../getBabelConfig.js'\n\n/**\n * Register Babel with the given options\n *\n * @param babelOptions - The options to use when registering Babel\n * @beta\n */\nexport function registerBabel(babelOptions?: TransformOptions): void {\n  const options = babelOptions || getBabelConfig()\n\n  register({...options, extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']})\n}\n"],"names":["register","getBabelConfig","registerBabel","babelOptions","options","extensions"],"mappings":"AACA,OAAOA,cAAc,kBAAiB;AAEtC,SAAQC,cAAc,QAAO,uBAAsB;AAEnD;;;;;CAKC,GACD,OAAO,SAASC,cAAcC,YAA+B;IAC3D,MAAMC,UAAUD,gBAAgBF;IAEhCD,SAAS;QAAC,GAAGI,OAAO;QAAEC,YAAY;YAAC;YAAO;YAAQ;YAAO;YAAQ;YAAQ;SAAO;IAAA;AAClF"}

package/dist/typescript/schemaTypeGenerator.js

@@ -0,0 +1,323 @@
+import * as t from '@babel/types';
+import { typeEvaluate } from 'groq-js';
+import { safeParseQuery } from '../safeParseQuery.js';
+import { ARRAY_OF, INTERNAL_REFERENCE_SYMBOL } from './constants.js';
+import { getFilterArrayUnionType, getUniqueIdentifierForName, isIdentifierName, weakMapMemo } from './helpers.js';
+export class SchemaTypeGenerator {
+    schema;
+    evaluateQuery = weakMapMemo(// eslint-disable-next-line unicorn/consistent-function-scoping
+    ({ query })=>{
+        const ast = safeParseQuery(query);
+        const typeNode = typeEvaluate(ast, this.schema);
+        const tsType = this.generateTsType(typeNode);
+        const stats = walkAndCountQueryTypeNodeStats(typeNode);
+        return {
+            stats,
+            tsType
+        };
+    });
+    identifiers = new Map();
+    tsTypes = new Map();
+    constructor(schema){
+        this.schema = schema;
+        const uniqueTypeNames = new Set();
+        for (const type of schema){
+            if (uniqueTypeNames.has(type.name)) {
+                throw new Error(`Duplicate type name "${type.name}" in schema. Type names must be unique within the same schema.`);
+            }
+            uniqueTypeNames.add(type.name);
+        }
+        for (const type of schema){
+            const currentIdentifierNames = new Set([
+                ...this.identifiers.values()
+            ].map((id)=>id.name));
+            const uniqueIdentifier = getUniqueIdentifierForName(type.name, currentIdentifierNames);
+            this.identifiers.set(type.name, uniqueIdentifier);
+        }
+        for (const type of schema){
+            this.tsTypes.set(type.name, this.generateTsType(type));
+        }
+    }
+    getType(typeName) {
+        const tsType = this.tsTypes.get(typeName);
+        const id = this.identifiers.get(typeName);
+        if (tsType && id) return {
+            id,
+            tsType
+        };
+        return undefined;
+    }
+    hasType(typeName) {
+        return this.tsTypes.has(typeName);
+    }
+    *[Symbol.iterator]() {
+        for (const { name } of this.schema){
+            yield {
+                name,
+                ...this.getType(name)
+            };
+        }
+    }
+    typeNames() {
+        return this.schema.map((schemaType)=>schemaType.name);
+    }
+    /**
+   * Helper function used to generate TS types for arrays of inline types, or arrays of inline types
+   * wrapped in the ArrayOf wrapper that adds _key prop
+   */ generateArrayOfTsType(typeNode) {
+        const typeNodes = this.generateTsType(typeNode.of);
+        return t.tsTypeReference(ARRAY_OF, t.tsTypeParameterInstantiation([
+            typeNodes
+        ]));
+    }
+    // Helper function used to generate TS types for array type nodes.
+    generateArrayTsType(typeNode) {
+        // if it's an array of a single inline type, wrap it in ArrayOf
+        if (typeNode.of.type === 'inline') {
+            return this.generateArrayOfTsType(typeNode);
+        }
+        // if it's not an inline object and not a union, wrap in Array
+        if (typeNode.of.type !== 'union') {
+            const typeNodes = this.generateTsType(typeNode.of);
+            return t.tsTypeReference(t.identifier('Array'), t.tsTypeParameterInstantiation([
+                typeNodes
+            ]));
+        }
+        // if it's not a union type or all of the union type members are non-inlines, wrap type in Array
+        if (typeNode.of.of.every((unionTypeNode)=>unionTypeNode.type !== 'inline')) {
+            const typeNodes = this.generateTsType(typeNode.of);
+            return t.tsTypeReference(t.identifier('Array'), t.tsTypeParameterInstantiation([
+                typeNodes
+            ]));
+        }
+        // all the union types nodes are inline
+        if (typeNode.of.of.every((unionMember)=>unionMember.type === 'inline')) {
+            return this.generateArrayOfTsType(typeNode);
+        }
+        // some of the union types are inlines, while some are not - split and recurse
+        const arrayOfNonInline = getFilterArrayUnionType(typeNode, (member)=>member.type !== 'inline');
+        const arrayOfInline = getFilterArrayUnionType(typeNode, (member)=>member.type === 'inline');
+        return t.tsUnionType([
+            this.generateArrayTsType(arrayOfNonInline),
+            this.generateArrayTsType(arrayOfInline)
+        ]);
+    }
+    // Helper function used to generate TS types for document type nodes.
+    generateDocumentTsType(document) {
+        const props = Object.entries(document.attributes).map(([key, node])=>this.generateTsObjectProperty(key, node));
+        return t.tsTypeLiteral(props);
+    }
+    generateInlineTsType(typeNode) {
+        const id = this.identifiers.get(typeNode.name);
+        if (!id) {
+            // Not found in schema, return unknown type
+            return t.addComment(t.tsUnknownKeyword(), 'trailing', ` Unable to locate the referenced type "${typeNode.name}" in schema`, true);
+        }
+        return t.tsTypeReference(id);
+    }
+    // Helper function used to generate TS types for object type nodes.
+    generateObjectTsType(typeNode) {
+        const props = [];
+        for (const [key, attribute] of Object.entries(typeNode.attributes)){
+            props.push(this.generateTsObjectProperty(key, attribute));
+        }
+        const rest = typeNode.rest;
+        if (rest) {
+            switch(rest.type){
+                case 'inline':
+                    {
+                        const resolved = this.generateInlineTsType(rest);
+                        // if object rest is unknown, we can't generate a type literal for it
+                        if (t.isTSUnknownKeyword(resolved)) return resolved;
+                        return t.tsIntersectionType([
+                            t.tsTypeLiteral(props),
+                            resolved
+                        ]);
+                    }
+                case 'object':
+                    {
+                        for (const [key, attribute] of Object.entries(rest.attributes)){
+                            props.push(this.generateTsObjectProperty(key, attribute));
+                        }
+                        break;
+                    }
+                case 'unknown':
+                    {
+                        return t.tsUnknownKeyword();
+                    }
+                default:
+                    {
+                        // @ts-expect-error This should never happen
+                        throw new Error(`Type "${rest.type}" not found in schema`);
+                    }
+            }
+        }
+        if (typeNode.dereferencesTo) {
+            const derefType = Object.assign(t.tsPropertySignature(INTERNAL_REFERENCE_SYMBOL, t.tsTypeAnnotation(t.tsLiteralType(t.stringLiteral(typeNode.dereferencesTo)))), {
+                computed: true,
+                optional: true
+            });
+            props.push(derefType);
+        }
+        return t.tsTypeLiteral(props);
+    }
+    // Helper function used to generate TS types for object properties.
+    generateTsObjectProperty(key, attribute) {
+        const type = this.generateTsType(attribute.value);
+        const keyNode = isIdentifierName(key) ? t.identifier(key) : t.stringLiteral(key);
+        const propertySignature = t.tsPropertySignature(keyNode, t.tsTypeAnnotation(type));
+        propertySignature.optional = attribute.optional;
+        return propertySignature;
+    }
+    generateTsType(typeNode) {
+        switch(typeNode.type){
+            case 'array':
+                {
+                    return this.generateArrayTsType(typeNode);
+                }
+            case 'boolean':
+                {
+                    if (typeNode.value !== undefined) {
+                        return t.tsLiteralType(t.booleanLiteral(typeNode.value));
+                    }
+                    return t.tsBooleanKeyword();
+                }
+            case 'document':
+                {
+                    return this.generateDocumentTsType(typeNode);
+                }
+            case 'inline':
+                {
+                    return this.generateInlineTsType(typeNode);
+                }
+            case 'null':
+                {
+                    return t.tsNullKeyword();
+                }
+            case 'number':
+                {
+                    if (typeNode.value !== undefined) {
+                        return t.tsLiteralType(t.numericLiteral(typeNode.value));
+                    }
+                    return t.tsNumberKeyword();
+                }
+            case 'object':
+                {
+                    return this.generateObjectTsType(typeNode);
+                }
+            case 'string':
+                {
+                    if (typeNode.value !== undefined) {
+                        return t.tsLiteralType(t.stringLiteral(typeNode.value));
+                    }
+                    return t.tsStringKeyword();
+                }
+            case 'type':
+                {
+                    return this.generateTsType(typeNode.value);
+                }
+            case 'union':
+                {
+                    return this.generateUnionTsType(typeNode);
+                }
+            case 'unknown':
+                {
+                    return t.tsUnknownKeyword();
+                }
+            default:
+                {
+                    throw new Error(`Encountered unsupported node type "${// @ts-expect-error This should never happen
+                    typeNode.type}" while generating schema types`);
+                }
+        }
+    }
+    // Helper function used to generate TS types for union type nodes.
+    generateUnionTsType(typeNode) {
+        if (typeNode.of.length === 0) return t.tsNeverKeyword();
+        if (typeNode.of.length === 1) return this.generateTsType(typeNode.of[0]);
+        return t.tsUnionType(typeNode.of.map((node)=>this.generateTsType(node)));
+    }
+}
+export function walkAndCountQueryTypeNodeStats(typeNode) {
+    switch(typeNode.type){
+        case 'array':
+            {
+                const acc = walkAndCountQueryTypeNodeStats(typeNode.of);
+                acc.allTypes += 1; // count the array type itself
+                return acc;
+            }
+        case 'object':
+            {
+                // if the rest is unknown, we count it as one unknown type
+                if (typeNode.rest && typeNode.rest.type === 'unknown') {
+                    return {
+                        allTypes: 2,
+                        emptyUnions: 0,
+                        unknownTypes: 1
+                    } // count the object type itself as well
+                    ;
+                }
+                const restStats = typeNode.rest ? walkAndCountQueryTypeNodeStats(typeNode.rest) : {
+                    allTypes: 0,
+                    emptyUnions: 0,
+                    unknownTypes: 0
+                };
+                // count the object type itself
+                restStats.allTypes += 1;
+                const attrs = Object.values(typeNode.attributes);
+                let acc = restStats;
+                for (const attribute of attrs){
+                    const { allTypes, emptyUnions, unknownTypes } = walkAndCountQueryTypeNodeStats(attribute.value);
+                    acc = {
+                        allTypes: acc.allTypes + allTypes,
+                        emptyUnions: acc.emptyUnions + emptyUnions,
+                        unknownTypes: acc.unknownTypes + unknownTypes
+                    };
+                }
+                return acc;
+            }
+        case 'union':
+            {
+                if (typeNode.of.length === 0) {
+                    return {
+                        allTypes: 1,
+                        emptyUnions: 1,
+                        unknownTypes: 0
+                    };
+                }
+                let acc = {
+                    allTypes: 1,
+                    emptyUnions: 0,
+                    unknownTypes: 0
+                } // count the union type itself
+                ;
+                for (const type of typeNode.of){
+                    const { allTypes, emptyUnions, unknownTypes } = walkAndCountQueryTypeNodeStats(type);
+                    acc = {
+                        allTypes: acc.allTypes + allTypes,
+                        emptyUnions: acc.emptyUnions + emptyUnions,
+                        unknownTypes: acc.unknownTypes + unknownTypes
+                    };
+                }
+                return acc;
+            }
+        case 'unknown':
+            {
+                return {
+                    allTypes: 1,
+                    emptyUnions: 0,
+                    unknownTypes: 1
+                };
+            }
+        default:
+            {
+                return {
+                    allTypes: 1,
+                    emptyUnions: 0,
+                    unknownTypes: 0
+                };
+            }
+    }
+}
+
+//# sourceMappingURL=schemaTypeGenerator.js.map