@sanity/codegen 5.7.0-next.8 → 5.7.0

package/dist/index.d.ts

@@ -0,0 +1,459 @@
+import { ExprNode } from 'groq-js';
+import { SchemaType } from 'groq-js';
+import * as t from '@babel/types';
+import { TransformOptions } from '@babel/core';
+import { WorkerChannel } from '@sanity/worker-channels';
+import { WorkerChannelReporter } from '@sanity/worker-channels';
+import * as z from 'zod';
+
+/**
+ * @deprecated use TypeGenConfig
+ */
+export declare type CodegenConfig = TypeGenConfig;
+
+/**
+ * @internal
+ */
+export declare const configDefinition: z.ZodObject<{
+    formatGeneratedCode: z.ZodDefault<z.ZodBoolean>;
+    generates: z.ZodDefault<z.ZodString>;
+    overloadClientMethods: z.ZodDefault<z.ZodBoolean>;
+    path: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    schema: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    formatGeneratedCode: boolean;
+    generates: string;
+    overloadClientMethods: boolean;
+    path: string | string[];
+    schema: string;
+}, {
+    formatGeneratedCode?: boolean | undefined;
+    generates?: string | undefined;
+    overloadClientMethods?: boolean | undefined;
+    path?: string | string[] | undefined;
+    schema?: string | undefined;
+}>;
+
+/**
+ * A module containing queries that have been evaluated.
+ * @public
+ */
+export declare interface EvaluatedModule {
+    errors: (QueryEvaluationError | QueryExtractionError)[];
+    filename: string;
+    queries: EvaluatedQuery[];
+}
+
+/**
+ * An `ExtractedQuery` that has been evaluated against a schema, yielding a TypeScript type.
+ * @public
+ */
+export declare interface EvaluatedQuery extends ExtractedQuery {
+    ast: t.ExportNamedDeclaration;
+    code: string;
+    id: t.Identifier;
+    stats: TypeEvaluationStats;
+    tsType: t.TSType;
+}
+
+/**
+ * A module (file) containing extracted GROQ queries.
+ * @public
+ */
+export declare interface ExtractedModule {
+    errors: QueryExtractionError[];
+    filename: string;
+    queries: ExtractedQuery[];
+}
+
+/**
+ * A GROQ query extracted from a source file.
+ * @public
+ */
+export declare interface ExtractedQuery {
+    filename: string;
+    query: string;
+    variable: QueryVariable;
+}
+
+/**
+ * Filter a union of object types by the _type property. This is handy when working with page builder
+ * setups where the returned type is an array containing multiple types.
+ *
+ * @example
+ * ```ts
+ *
+ * export type Callout = {
+ *   _type: 'callout'
+ *   title?: string
+ *   content?: string
+ * }
+ *
+ * export type Video = {
+ *   _type: 'video'
+ *   url?: string
+ *   caption?: string
+ * }
+ * type FORM_QUERY_RESULT = {
+ *   _id: string
+ *   title?: string
+ *   content?: Array<
+ *     | ({ _key: string } & Callout)
+ *     | ({ _key: string } & Video)
+ *   >
+ * } | null
+ *
+ * // Get the type of the content with the Get helper
+ * type Content = Get<FORM_QUERY_RESULT, 'content', number>
+ *
+ * // Get the type for a callout module from the page builder type
+ * type CalloutModule = FilterByType<Content, 'callout'>
+ * // → { _key: string } & Callout
+ * ```
+ */
+export declare type FilterByType<U extends {
+    _type: string;
+}, T extends U['_type']> = Extract<U, {
+    _type: T;
+}>;
+
+/**
+ * findQueriesInPath takes a path or array of paths and returns all GROQ queries in the files.
+ * @param path - The path or array of paths to search for queries
+ * @param babelOptions - The babel configuration to use when parsing the source
+ * @param resolver - A resolver function to use when resolving module imports
+ * @returns An async generator that yields the results of the search
+ * @beta
+ * @internal
+ */
+export declare function findQueriesInPath({ babelOptions, path, resolver, }: FindQueriesInPathOptions): {
+    files: string[];
+    queries: AsyncIterable<ExtractedModule>;
+};
+
+declare interface FindQueriesInPathOptions {
+    path: string | string[];
+    babelOptions?: TransformOptions;
+    resolver?: NodeJS.RequireResolve;
+}
+
+/**
+ * findQueriesInSource takes a source string and returns all GROQ queries in it.
+ * @param source - The source code to search for queries
+ * @param filename - The filename of the source code
+ * @param babelConfig - The babel configuration to use when parsing the source
+ * @param resolver - A resolver function to use when resolving module imports
+ * @returns
+ * @beta
+ * @internal
+ */
+export declare function findQueriesInSource(source: string, filename: string, babelConfig?: TransformOptions, resolver?: NodeJS.RequireResolve): ExtractedModule;
+
+export declare interface GenerateTypesOptions {
+    schema: SchemaType;
+    overloadClientMethods?: boolean;
+    queries?: AsyncIterable<ExtractedModule>;
+    reporter?: WorkerChannelReporter<TypegenWorkerChannel>;
+    root?: string;
+    schemaPath?: string;
+}
+
+/**
+ * Get a deeply nested property type from a complex type structure. Safely navigates
+ * through nullable types (`T | null | undefined`) at each level, preserving the
+ * nullability of the final accessed property.
+ *
+ * Supports up to 20 levels of nesting.
+ *
+ * @example
+ * ```ts
+ * type POST_QUERY_RESULT = {
+ *   _id: string
+ *   author: {
+ *     profile: {
+ *       name: string;
+ *     } | null;
+ *   } | null;
+ *   links: Array<{
+ *     _key: string
+ *     type: 'link'
+ *     label: string
+ *     url: string
+ *   }> | null
+ * } | null
+ *
+ * // Basic property access:
+ * type Id = Get<POST_QUERY_RESULT, '_id'>;
+ * // → string
+ *
+ * // Nested property access:
+ * type Profile = Get<POST_QUERY_RESULT, 'author', 'profile';
+ * // → { name: string } | null
+ *
+ * // Array element access using `number`:
+ * type Link = Get<POST_QUERY_RESULT, 'links', number, 'label'>;
+ * // → string
+ * ```
+ */
+export declare type Get<T, K1 extends keyof NonNullish<T>, K2 extends keyof NavigatePath<T, [K1]> = never, K3 extends keyof NavigatePath<T, [K1, K2]> = never, K4 extends keyof NavigatePath<T, [K1, K2, K3]> = never, K5 extends keyof NavigatePath<T, [K1, K2, K3, K4]> = never, K6 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5]> = never, K7 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6]> = never, K8 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7]> = never, K9 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8]> = never, K10 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9]> = never, K11 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10]> = never, K12 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11]> = never, K13 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12]> = never, K14 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13]> = never, K15 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14]> = never, K16 extends keyof NavigatePath<T, [
+K1,
+K2,
+K3,
+K4,
+K5,
+K6,
+K7,
+K8,
+K9,
+K10,
+K11,
+K12,
+K13,
+K14,
+K15
+]> = never, K17 extends keyof NavigatePath<T, [
+K1,
+K2,
+K3,
+K4,
+K5,
+K6,
+K7,
+K8,
+K9,
+K10,
+K11,
+K12,
+K13,
+K14,
+K15,
+K16
+]> = never, K18 extends keyof NavigatePath<T, [
+K1,
+K2,
+K3,
+K4,
+K5,
+K6,
+K7,
+K8,
+K9,
+K10,
+K11,
+K12,
+K13,
+K14,
+K15,
+K16,
+K17
+]> = never, K19 extends keyof NavigatePath<T, [
+K1,
+K2,
+K3,
+K4,
+K5,
+K6,
+K7,
+K8,
+K9,
+K10,
+K11,
+K12,
+K13,
+K14,
+K15,
+K16,
+K17,
+K18
+]> = never, K20 extends keyof NavigatePath<T, [
+K1,
+K2,
+K3,
+K4,
+K5,
+K6,
+K7,
+K8,
+K9,
+K10,
+K11,
+K12,
+K13,
+K14,
+K15,
+K16,
+K17,
+K18,
+K19
+]> = never> = GetAtPath<T, TakeUntilNever<[
+K1,
+K2,
+K3,
+K4,
+K5,
+K6,
+K7,
+K8,
+K9,
+K10,
+K11,
+K12,
+K13,
+K14,
+K15,
+K16,
+K17,
+K18,
+K19,
+K20
+]>>;
+
+/** Recursively gets value at path, preserving nullability at final access. */
+declare type GetAtPath<T, Path extends unknown[]> = Path extends [] ? T : Path extends [infer K] ? K extends keyof NonNullish<T> ? NonNullish<T>[K] : never : Path extends [infer K, ...infer Rest] ? K extends keyof NonNullish<T> ? GetAtPath<NonNullish<T>[K], Rest> : never : never;
+
+/**
+ * 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 declare function getResolver(cwd?: string): NodeJS.RequireResolve;
+
+/** Recursively navigates through a path, stripping nullability for key lookup. */
+declare type NavigatePath<T, Path extends unknown[]> = Path extends [] ? NonNullish<T> : Path extends [infer K, ...infer Rest] ? K extends keyof NonNullish<T> ? NavigatePath<NonNullish<T>[K], Rest> : never : never;
+
+/** Excludes `null` and `undefined` from a type. */
+declare type NonNullish<T> = T extends null | undefined ? never : T;
+
+/**
+ * An error that occurred during query evaluation.
+ * @public
+ */
+declare class QueryEvaluationError extends Error {
+    filename: string;
+    variable?: QueryVariable;
+    constructor({ cause, filename, variable }: QueryEvaluationErrorOptions);
+}
+
+declare interface QueryEvaluationErrorOptions {
+    cause: unknown;
+    filename: string;
+    variable?: QueryVariable;
+}
+
+/**
+ * An error that occurred during query extraction.
+ * @public
+ */
+export declare class QueryExtractionError extends Error {
+    filename: string;
+    variable?: QueryVariable;
+    constructor({ cause, filename, variable }: QueryExtractionErrorOptions);
+}
+
+declare interface QueryExtractionErrorOptions {
+    cause: unknown;
+    filename: string;
+    variable?: QueryVariable;
+}
+
+declare interface QueryVariable {
+    id: t.Identifier;
+    end?: number;
+    start?: number;
+}
+
+/**
+ * Read, parse and process a config file
+ * @internal
+ */
+export declare function readConfig(path: string): Promise<TypeGenConfig>;
+
+/**
+ * Read a schema from a given path
+ * @param path - The path to the schema
+ * @returns The schema
+ * @internal
+ * @beta
+ **/
+export declare function readSchema(path: string): Promise<SchemaType>;
+
+/**
+ * Register Babel with the given options
+ *
+ * @param babelOptions - The options to use when registering Babel
+ * @beta
+ */
+export declare function registerBabel(babelOptions?: TransformOptions): void;
+
+/**
+ * safeParseQuery parses a GROQ query string, but first attempts to extract any parameters used in slices. This method is _only_
+ * intended for use in type generation where we don't actually execute the parsed AST on a dataset, and should not be used elsewhere.
+ * @internal
+ */
+export declare function safeParseQuery(query: string): ExprNode;
+
+/** Builds a tuple from elements, stopping at the first `never`. */
+declare type TakeUntilNever<T extends unknown[]> = T extends [infer H, ...infer Rest] ? [H] extends [never] ? [] : [H, ...TakeUntilNever<Rest>] : [];
+
+/**
+ * Statistics from the query type evaluation process.
+ * @public
+ */
+declare interface TypeEvaluationStats {
+    allTypes: number;
+    emptyUnions: number;
+    unknownTypes: number;
+}
+
+export declare type TypeGenConfig = z.infer<typeof configDefinition>;
+
+/**
+ * A class used to generate TypeScript types from a given schema
+ * @beta
+ */
+export declare class TypeGenerator {
+    private getSchemaTypeGenerator;
+    private getSchemaTypeDeclarations;
+    private getAllSanitySchemaTypesDeclaration;
+    private getArrayOfDeclaration;
+    private getInternalReferenceSymbolDeclaration;
+    private static getEvaluatedModules;
+    private static getQueryMapDeclaration;
+    generateTypes(options: GenerateTypesOptions): Promise<{
+        ast: t.Program;
+        code: string;
+    }>;
+}
+
+export declare type TypegenWorkerChannel = WorkerChannel.Definition<{
+    evaluatedModules: WorkerChannel.Stream<EvaluatedModule>;
+    generatedQueryTypes: WorkerChannel.Event<{
+        queryMapDeclaration: {
+            ast: t.Program;
+            code: string;
+        };
+    }>;
+    generatedSchemaTypes: WorkerChannel.Event<{
+        allSanitySchemaTypesDeclaration: {
+            ast: t.ExportNamedDeclaration;
+            code: string;
+            id: t.Identifier;
+        };
+        internalReferenceSymbol: {
+            ast: t.ExportNamedDeclaration;
+            code: string;
+            id: t.Identifier;
+        };
+        schemaTypeDeclarations: {
+            ast: t.ExportNamedDeclaration;
+            code: string;
+            id: t.Identifier;
+            name: string;
+            tsType: t.TSType;
+        }[];
+    }>;
+}>;
+
+export { }

package/dist/readConfig.js

@@ -0,0 +1,38 @@
+import { readFile } from 'node:fs/promises';
+import json5 from 'json5';
+import * as z from 'zod';
+/**
+ * @internal
+ */ export const configDefinition = z.object({
+    formatGeneratedCode: z.boolean().default(true),
+    generates: z.string().default('./sanity.types.ts'),
+    overloadClientMethods: z.boolean().default(true),
+    path: z.string().or(z.array(z.string())).default([
+        './src/**/*.{ts,tsx,js,jsx,mjs,cjs,astro,vue,svelte}',
+        './app/**/*.{ts,tsx,js,jsx,mjs,cjs,astro,vue,svelte}',
+        './sanity/**/*.{ts,tsx,js,jsx,mjs,cjs}'
+    ]),
+    schema: z.string().default('./schema.json')
+});
+/**
+ * Read, parse and process a config file
+ * @internal
+ */ export async function readConfig(path) {
+    try {
+        const content = await readFile(path, 'utf8');
+        const json = json5.parse(content);
+        return configDefinition.parseAsync(json);
+    } catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new Error(`Error in config file\n ${error.errors.map((err)=>err.message).join('\n')}`, {
+                cause: error
+            });
+        }
+        if (typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT') {
+            return configDefinition.parse({});
+        }
+        throw error;
+    }
+}
+
+//# sourceMappingURL=readConfig.js.map

package/dist/readConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/readConfig.ts"],"sourcesContent":["import {readFile} from 'node:fs/promises'\n\nimport json5 from 'json5'\nimport * as z from 'zod'\n\n/**\n * @internal\n */\nexport const configDefinition = z.object({\n  formatGeneratedCode: z.boolean().default(true),\n  generates: z.string().default('./sanity.types.ts'),\n  overloadClientMethods: z.boolean().default(true),\n  path: z\n    .string()\n    .or(z.array(z.string()))\n    .default([\n      './src/**/*.{ts,tsx,js,jsx,mjs,cjs,astro,vue,svelte}',\n      './app/**/*.{ts,tsx,js,jsx,mjs,cjs,astro,vue,svelte}',\n      './sanity/**/*.{ts,tsx,js,jsx,mjs,cjs}',\n    ]),\n  schema: z.string().default('./schema.json'),\n})\n\nexport type TypeGenConfig = z.infer<typeof configDefinition>\n\n/**\n * @deprecated use TypeGenConfig\n */\nexport type CodegenConfig = TypeGenConfig\n\n/**\n * Read, parse and process a config file\n * @internal\n */\nexport async function readConfig(path: string): Promise<TypeGenConfig> {\n  try {\n    const content = await readFile(path, 'utf8')\n    const json = json5.parse(content)\n    return configDefinition.parseAsync(json)\n  } catch (error) {\n    if (error instanceof z.ZodError) {\n      throw new Error(\n        `Error in config file\\n ${error.errors.map((err) => err.message).join('\\n')}`,\n        {cause: error},\n      )\n    }\n    if (typeof error === 'object' && error !== null && 'code' in error && error.code === 'ENOENT') {\n      return configDefinition.parse({})\n    }\n\n    throw error\n  }\n}\n"],"names":["readFile","json5","z","configDefinition","object","formatGeneratedCode","boolean","default","generates","string","overloadClientMethods","path","or","array","schema","readConfig","content","json","parse","parseAsync","error","ZodError","Error","errors","map","err","message","join","cause","code"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AAEzC,OAAOC,WAAW,QAAO;AACzB,YAAYC,OAAO,MAAK;AAExB;;CAEC,GACD,OAAO,MAAMC,mBAAmBD,EAAEE,MAAM,CAAC;IACvCC,qBAAqBH,EAAEI,OAAO,GAAGC,OAAO,CAAC;IACzCC,WAAWN,EAAEO,MAAM,GAAGF,OAAO,CAAC;IAC9BG,uBAAuBR,EAAEI,OAAO,GAAGC,OAAO,CAAC;IAC3CI,MAAMT,EACHO,MAAM,GACNG,EAAE,CAACV,EAAEW,KAAK,CAACX,EAAEO,MAAM,KACnBF,OAAO,CAAC;QACP;QACA;QACA;KACD;IACHO,QAAQZ,EAAEO,MAAM,GAAGF,OAAO,CAAC;AAC7B,GAAE;AASF;;;CAGC,GACD,OAAO,eAAeQ,WAAWJ,IAAY;IAC3C,IAAI;QACF,MAAMK,UAAU,MAAMhB,SAASW,MAAM;QACrC,MAAMM,OAAOhB,MAAMiB,KAAK,CAACF;QACzB,OAAOb,iBAAiBgB,UAAU,CAACF;IACrC,EAAE,OAAOG,OAAO;QACd,IAAIA,iBAAiBlB,EAAEmB,QAAQ,EAAE;YAC/B,MAAM,IAAIC,MACR,CAAC,uBAAuB,EAAEF,MAAMG,MAAM,CAACC,GAAG,CAAC,CAACC,MAAQA,IAAIC,OAAO,EAAEC,IAAI,CAAC,OAAO,EAC7E;gBAACC,OAAOR;YAAK;QAEjB;QACA,IAAI,OAAOA,UAAU,YAAYA,UAAU,QAAQ,UAAUA,SAASA,MAAMS,IAAI,KAAK,UAAU;YAC7F,OAAO1B,iBAAiBe,KAAK,CAAC,CAAC;QACjC;QAEA,MAAME;IACR;AACF"}

package/dist/readSchema.js

@@ -0,0 +1,14 @@
+import { readFile } from 'node:fs/promises';
+/**
+ * Read a schema from a given path
+ * @param path - The path to the schema
+ * @returns The schema
+ * @internal
+ * @beta
+ **/ export async function readSchema(path) {
+    const content = await readFile(path, 'utf8');
+    return JSON.parse(content) // todo: ZOD validation?
+    ;
+}
+
+//# sourceMappingURL=readSchema.js.map

package/dist/readSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/readSchema.ts"],"sourcesContent":["import {readFile} from 'node:fs/promises'\n\nimport {type SchemaType} from 'groq-js'\n\n/**\n * Read a schema from a given path\n * @param path - The path to the schema\n * @returns The schema\n * @internal\n * @beta\n **/\nexport async function readSchema(path: string): Promise<SchemaType> {\n  const content = await readFile(path, 'utf8')\n  return JSON.parse(content) // todo: ZOD validation?\n}\n"],"names":["readFile","readSchema","path","content","JSON","parse"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AAIzC;;;;;;EAME,GACF,OAAO,eAAeC,WAAWC,IAAY;IAC3C,MAAMC,UAAU,MAAMH,SAASE,MAAM;IACrC,OAAOE,KAAKC,KAAK,CAACF,SAAS,wBAAwB;;AACrD"}

package/dist/safeParseQuery.js

@@ -0,0 +1,37 @@
+import { parse } from 'groq-js';
+/**
+ * safeParseQuery parses a GROQ query string, but first attempts to extract any parameters used in slices. This method is _only_
+ * intended for use in type generation where we don't actually execute the parsed AST on a dataset, and should not be used elsewhere.
+ * @internal
+ */ export function safeParseQuery(query) {
+    const params = {};
+    for (const param of extractSliceParams(query)){
+        params[param] = 0; // we don't care about the value, just the type
+    }
+    return parse(query, {
+        params
+    });
+}
+/**
+ * Finds occurences of `[($start|{number})..($end|{number})]` in a query string and returns the start and end values, and return
+ * the names of the start and end variables.
+ * @internal
+ */ export function* extractSliceParams(query) {
+    const sliceRegex = /\[(\$(\w+)|\d)\.\.\.?(\$(\w+)|\d)\]/g;
+    const matches = query.matchAll(sliceRegex);
+    if (!matches) {
+        return;
+    }
+    for (const match of matches){
+        const start = match[1] === `$${match[2]}` ? match[2] : null;
+        if (start !== null) {
+            yield start;
+        }
+        const end = match[3] === `$${match[4]}` ? match[4] : null;
+        if (end !== null) {
+            yield end;
+        }
+    }
+}
+
+//# sourceMappingURL=safeParseQuery.js.map

package/dist/safeParseQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/safeParseQuery.ts"],"sourcesContent":["import {parse} from 'groq-js'\n\n/**\n * safeParseQuery parses a GROQ query string, but first attempts to extract any parameters used in slices. This method is _only_\n * intended for use in type generation where we don't actually execute the parsed AST on a dataset, and should not be used elsewhere.\n * @internal\n */\nexport function safeParseQuery(query: string) {\n  const params: Record<string, unknown> = {}\n\n  for (const param of extractSliceParams(query)) {\n    params[param] = 0 // we don't care about the value, just the type\n  }\n  return parse(query, {params})\n}\n\n/**\n * Finds occurences of `[($start|{number})..($end|{number})]` in a query string and returns the start and end values, and return\n * the names of the start and end variables.\n * @internal\n */\nexport function* extractSliceParams(query: string): Generator<string> {\n  const sliceRegex = /\\[(\\$(\\w+)|\\d)\\.\\.\\.?(\\$(\\w+)|\\d)\\]/g\n  const matches = query.matchAll(sliceRegex)\n  if (!matches) {\n    return\n  }\n  for (const match of matches) {\n    const start = match[1] === `$${match[2]}` ? match[2] : null\n    if (start !== null) {\n      yield start!\n    }\n    const end = match[3] === `$${match[4]}` ? match[4] : null\n    if (end !== null) {\n      yield end!\n    }\n  }\n}\n"],"names":["parse","safeParseQuery","query","params","param","extractSliceParams","sliceRegex","matches","matchAll","match","start","end"],"mappings":"AAAA,SAAQA,KAAK,QAAO,UAAS;AAE7B;;;;CAIC,GACD,OAAO,SAASC,eAAeC,KAAa;IAC1C,MAAMC,SAAkC,CAAC;IAEzC,KAAK,MAAMC,SAASC,mBAAmBH,OAAQ;QAC7CC,MAAM,CAACC,MAAM,GAAG,GAAE,+CAA+C;IACnE;IACA,OAAOJ,MAAME,OAAO;QAACC;IAAM;AAC7B;AAEA;;;;CAIC,GACD,OAAO,UAAUE,mBAAmBH,KAAa;IAC/C,MAAMI,aAAa;IACnB,MAAMC,UAAUL,MAAMM,QAAQ,CAACF;IAC/B,IAAI,CAACC,SAAS;QACZ;IACF;IACA,KAAK,MAAME,SAASF,QAAS;QAC3B,MAAMG,QAAQD,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,EAAEA,KAAK,CAAC,EAAE,EAAE,GAAGA,KAAK,CAAC,EAAE,GAAG;QACvD,IAAIC,UAAU,MAAM;YAClB,MAAMA;QACR;QACA,MAAMC,MAAMF,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,EAAEA,KAAK,CAAC,EAAE,EAAE,GAAGA,KAAK,CAAC,EAAE,GAAG;QACrD,IAAIE,QAAQ,MAAM;YAChB,MAAMA;QACR;IACF;AACF"}

package/dist/typeUtils.js

@@ -0,0 +1,37 @@
+/** Excludes `null` and `undefined` from a type. */ /**
+ * Filter a union of object types by the _type property. This is handy when working with page builder
+ * setups where the returned type is an array containing multiple types.
+ *
+ * @example
+ * ```ts
+ *
+ * export type Callout = {
+ *   _type: 'callout'
+ *   title?: string
+ *   content?: string
+ * }
+ *
+ * export type Video = {
+ *   _type: 'video'
+ *   url?: string
+ *   caption?: string
+ * }
+ * type FORM_QUERY_RESULT = {
+ *   _id: string
+ *   title?: string
+ *   content?: Array<
+ *     | ({ _key: string } & Callout)
+ *     | ({ _key: string } & Video)
+ *   >
+ * } | null
+ *
+ * // Get the type of the content with the Get helper
+ * type Content = Get<FORM_QUERY_RESULT, 'content', number>
+ *
+ * // Get the type for a callout module from the page builder type
+ * type CalloutModule = FilterByType<Content, 'callout'>
+ * // → { _key: string } & Callout
+ * ```
+ */ export { };
+
+//# sourceMappingURL=typeUtils.js.map

package/dist/typeUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/typeUtils.ts"],"sourcesContent":["/** Excludes `null` and `undefined` from a type. */\ntype NonNullish<T> = T extends null | undefined ? never : T\n\n/** Builds a tuple from elements, stopping at the first `never`. */\ntype TakeUntilNever<T extends unknown[]> = T extends [infer H, ...infer Rest]\n  ? [H] extends [never]\n    ? []\n    : [H, ...TakeUntilNever<Rest>]\n  : []\n\n/** Recursively navigates through a path, stripping nullability for key lookup. */\ntype NavigatePath<T, Path extends unknown[]> = Path extends []\n  ? NonNullish<T>\n  : Path extends [infer K, ...infer Rest]\n    ? K extends keyof NonNullish<T>\n      ? NavigatePath<NonNullish<T>[K], Rest>\n      : never\n    : never\n\n/** Recursively gets value at path, preserving nullability at final access. */\ntype GetAtPath<T, Path extends unknown[]> = Path extends []\n  ? T\n  : Path extends [infer K]\n    ? K extends keyof NonNullish<T>\n      ? NonNullish<T>[K]\n      : never\n    : Path extends [infer K, ...infer Rest]\n      ? K extends keyof NonNullish<T>\n        ? GetAtPath<NonNullish<T>[K], Rest>\n        : never\n      : never\n\n/**\n * Get a deeply nested property type from a complex type structure. Safely navigates\n * through nullable types (`T | null | undefined`) at each level, preserving the\n * nullability of the final accessed property.\n *\n * Supports up to 20 levels of nesting.\n *\n * @example\n * ```ts\n * type POST_QUERY_RESULT = {\n *   _id: string\n *   author: {\n *     profile: {\n *       name: string;\n *     } | null;\n *   } | null;\n *   links: Array<{\n *     _key: string\n *     type: 'link'\n *     label: string\n *     url: string\n *   }> | null\n * } | null\n *\n * // Basic property access:\n * type Id = Get<POST_QUERY_RESULT, '_id'>;\n * // → string\n *\n * // Nested property access:\n * type Profile = Get<POST_QUERY_RESULT, 'author', 'profile';\n * // → { name: string } | null\n *\n * // Array element access using `number`:\n * type Link = Get<POST_QUERY_RESULT, 'links', number, 'label'>;\n * // → string\n * ```\n */\nexport type Get<\n  T,\n  K1 extends keyof NonNullish<T>,\n  K2 extends keyof NavigatePath<T, [K1]> = never,\n  K3 extends keyof NavigatePath<T, [K1, K2]> = never,\n  K4 extends keyof NavigatePath<T, [K1, K2, K3]> = never,\n  K5 extends keyof NavigatePath<T, [K1, K2, K3, K4]> = never,\n  K6 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5]> = never,\n  K7 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6]> = never,\n  K8 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7]> = never,\n  K9 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8]> = never,\n  K10 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9]> = never,\n  K11 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10]> = never,\n  K12 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11]> = never,\n  K13 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12]> = never,\n  K14 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13]> =\n    never,\n  K15 extends keyof NavigatePath<T, [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14]> =\n    never,\n  K16 extends keyof NavigatePath<\n    T,\n    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15]\n  > = never,\n  K17 extends keyof NavigatePath<\n    T,\n    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16]\n  > = never,\n  K18 extends keyof NavigatePath<\n    T,\n    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17]\n  > = never,\n  K19 extends keyof NavigatePath<\n    T,\n    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18]\n  > = never,\n  K20 extends keyof NavigatePath<\n    T,\n    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19]\n  > = never,\n> = GetAtPath<\n  T,\n  TakeUntilNever<\n    [K1, K2, K3, K4, K5, K6, K7, K8, K9, K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K20]\n  >\n>\n\n/**\n * Filter a union of object types by the _type property. This is handy when working with page builder\n * setups where the returned type is an array containing multiple types.\n *\n * @example\n * ```ts\n *\n * export type Callout = {\n *   _type: 'callout'\n *   title?: string\n *   content?: string\n * }\n *\n * export type Video = {\n *   _type: 'video'\n *   url?: string\n *   caption?: string\n * }\n * type FORM_QUERY_RESULT = {\n *   _id: string\n *   title?: string\n *   content?: Array<\n *     | ({ _key: string } & Callout)\n *     | ({ _key: string } & Video)\n *   >\n * } | null\n *\n * // Get the type of the content with the Get helper\n * type Content = Get<FORM_QUERY_RESULT, 'content', number>\n *\n * // Get the type for a callout module from the page builder type\n * type CalloutModule = FilterByType<Content, 'callout'>\n * // → { _key: string } & Callout\n * ```\n */\nexport type FilterByType<U extends {_type: string}, T extends U['_type']> = Extract<U, {_type: T}>\n"],"names":[],"mappings":"AAAA,iDAAiD,GAmHjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCC,GACD,WAAkG"}

package/dist/typescript/constants.js

@@ -0,0 +1,12 @@
+import * as t from '@babel/types';
+export const INTERNAL_REFERENCE_SYMBOL = t.identifier('internalGroqTypeReferenceTo');
+export const ALL_SANITY_SCHEMA_TYPES = t.identifier('AllSanitySchemaTypes');
+export const SANITY_QUERIES = t.identifier('SanityQueries');
+export const ARRAY_OF = t.identifier('ArrayOf');
+export const RESERVED_IDENTIFIERS = new Set();
+RESERVED_IDENTIFIERS.add(SANITY_QUERIES.name);
+RESERVED_IDENTIFIERS.add(ALL_SANITY_SCHEMA_TYPES.name);
+RESERVED_IDENTIFIERS.add(INTERNAL_REFERENCE_SYMBOL.name);
+RESERVED_IDENTIFIERS.add(ARRAY_OF.name);
+
+//# sourceMappingURL=constants.js.map

package/dist/typescript/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/typescript/constants.ts"],"sourcesContent":["import * as t from '@babel/types'\n\nexport const INTERNAL_REFERENCE_SYMBOL = t.identifier('internalGroqTypeReferenceTo')\nexport const ALL_SANITY_SCHEMA_TYPES = t.identifier('AllSanitySchemaTypes')\nexport const SANITY_QUERIES = t.identifier('SanityQueries')\nexport const ARRAY_OF = t.identifier('ArrayOf')\n\nexport const RESERVED_IDENTIFIERS = new Set<string>()\nRESERVED_IDENTIFIERS.add(SANITY_QUERIES.name)\nRESERVED_IDENTIFIERS.add(ALL_SANITY_SCHEMA_TYPES.name)\nRESERVED_IDENTIFIERS.add(INTERNAL_REFERENCE_SYMBOL.name)\nRESERVED_IDENTIFIERS.add(ARRAY_OF.name)\n"],"names":["t","INTERNAL_REFERENCE_SYMBOL","identifier","ALL_SANITY_SCHEMA_TYPES","SANITY_QUERIES","ARRAY_OF","RESERVED_IDENTIFIERS","Set","add","name"],"mappings":"AAAA,YAAYA,OAAO,eAAc;AAEjC,OAAO,MAAMC,4BAA4BD,EAAEE,UAAU,CAAC,+BAA8B;AACpF,OAAO,MAAMC,0BAA0BH,EAAEE,UAAU,CAAC,wBAAuB;AAC3E,OAAO,MAAME,iBAAiBJ,EAAEE,UAAU,CAAC,iBAAgB;AAC3D,OAAO,MAAMG,WAAWL,EAAEE,UAAU,CAAC,WAAU;AAE/C,OAAO,MAAMI,uBAAuB,IAAIC,MAAa;AACrDD,qBAAqBE,GAAG,CAACJ,eAAeK,IAAI;AAC5CH,qBAAqBE,GAAG,CAACL,wBAAwBM,IAAI;AACrDH,qBAAqBE,GAAG,CAACP,0BAA0BQ,IAAI;AACvDH,qBAAqBE,GAAG,CAACH,SAASI,IAAI"}