@shopify/hydrogen-codegen 0.3.2 → 0.3.3

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,SAAQ,cAAgC;AACxC,SAAQ,iBAAgB;AACxB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAOK","sourcesContent":["export {preset, type PresetConfig} from './preset.js';\nexport {getSchema} from './schema.js';\nexport {\n  plugin,\n  pluckConfig,\n  processSources,\n  type GenericVariables,\n  type EmptyVariables,\n  type ClientReturn,\n  type IsOptionalVariables,\n  type ClientVariables,\n  type ClientVariablesInRestParams,\n} from '@shopify/graphql-codegen';\n"]}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,SAAQ,cAAgC;AACxC,SAAQ,iBAAgB;AACxB;AAAA,EAOE;AAAA,EACA;AAAA,EACA;AAAA,OACK","sourcesContent":["export {preset, type PresetConfig} from './preset.js';\nexport {getSchema} from './schema.js';\nexport {\n  type ClientReturn,\n  type ClientVariables,\n  type ClientVariablesInRestParams,\n  type EmptyVariables,\n  type GenericVariables,\n  type IsOptionalVariables,\n  pluckConfig,\n  plugin,\n  processSources,\n} from '@shopify/graphql-codegen';\n"]}

package/dist/esm/index.d.ts

@@ -2,6 +2,96 @@ import { PluginFunction, Types } from '@graphql-codegen/plugin-helpers';
 import { Source } from '@graphql-tools/utils';
 import { ExecutionArgs, FragmentDefinitionNode, OperationDefinitionNode } from 'graphql';
 
+/**
+Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
+```
+
+A more applicable example which could make its way into your library code follows.
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+class CommandOne {
+	commands: {
+		a1: () => undefined,
+		b1: () => undefined,
+	}
+}
+
+class CommandTwo {
+	commands: {
+		a2: (argA: string) => undefined,
+		b2: (argB: string) => undefined,
+	}
+}
+
+const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
+type Union = typeof union;
+//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
+
+type Intersection = UnionToIntersection<Union>;
+//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
+```
+
+@category Type
+*/
+export type UnionToIntersection<Union> = (
+// `extends unknown` is always going to be the case and is used to convert the
+// `Union` into a [distributive conditional
+// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
+/**
+Create a union of all keys from a given type, even those exclusive to specific union members.
+
+Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
+
+@link https://stackoverflow.com/a/49402091
+
+@example
+```
+import type {KeysOfUnion} from 'type-fest';
+
+type A = {
+	common: string;
+	a: number;
+};
+
+type B = {
+	common: string;
+	b: string;
+};
+
+type C = {
+	common: string;
+	c: boolean;
+};
+
+type Union = A | B | C;
+
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
+```
+
+@category Object
+*/
+export type KeysOfUnion<ObjectType> = 
+// Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -28,7 +118,7 @@ type Includes<Value extends readonly any[], Item> =
 @category Type Guard
 @category Utilities
 */
-export type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends (<G>() => G extends B ? 1 : 2) ? true : false;
+export type IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 /**
 Filter out keys from an object.
 
@@ -96,6 +186,26 @@ type FooWithoutB = Except<Foo, 'b', {requireExactProps: true}>;
 
 const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
 //=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+
+// The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
+
+// Consider the following example:
+
+type UserData = {
+	[metadata: string]: string;
+	email: string;
+	name: string;
+	role: 'admin' | 'user';
+};
+
+// `Omit` clearly doesn't behave as expected in this case:
+type PostPayload = Omit<UserData, 'email'>;
+//=> type PostPayload = { [x: string]: string; [x: number]: string; }
+
+// In situations like this, `Except` works better.
+// It simply removes the `email` key while preserving all the other keys.
+type PostPayload = Except<UserData, 'email'>;
+//=> type PostPayload = { [x: string]: string; name: string; role: 'admin' | 'user'; }
 ```
 
 @category Object
@@ -212,6 +322,46 @@ export type IsNever<T> = [
 	never
 ] ? true : false;
 /**
+Works similar to the built-in `Pick` utility type, except for the following differences:
+- Distributes over union types and allows picking keys from any member of the union type.
+- Primitives types are returned as-is.
+- Picks all keys if `Keys` is `any`.
+- Doesn't pick `number` from a `string` index signature.
+
+@example
+```
+type ImageUpload = {
+	url: string;
+	size: number;
+	thumbnailUrl: string;
+};
+
+type VideoUpload = {
+	url: string;
+	duration: number;
+	encodingFormat: string;
+};
+
+// Distributes over union types and allows picking keys from any member of the union type
+type MediaDisplay = HomomorphicPick<ImageUpload | VideoUpload, "url" | "size" | "duration">;
+//=> {url: string; size: number} | {url: string; duration: number}
+
+// Primitive types are returned as-is
+type Primitive = HomomorphicPick<string | number, 'toUpperCase' | 'toString'>;
+//=> string | number
+
+// Picks all keys if `Keys` is `any`
+type Any = HomomorphicPick<{a: 1; b: 2} | {c: 3}, any>;
+//=> {a: 1; b: 2} | {c: 3}
+
+// Doesn't pick `number` from a `string` index signature
+type IndexSignature = HomomorphicPick<{[k: string]: unknown}, number>;
+//=> {}
+*/
+export type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {
+	[P in keyof T as Extract<P, Keys>]: T[P];
+};
+/**
 Create a type that makes the given keys optional. The remaining keys are kept as is. The sister of the `SetRequired` type.
 
 Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are optional.
@@ -236,11 +386,12 @@ type SomeOptional = SetOptional<Foo, 'b' | 'c'>;
 
 @category Object
 */
-export type SetOptional<BaseType, Keys extends keyof BaseType> = Simplify<
+export type SetOptional<BaseType, Keys extends keyof BaseType> = BaseType extends unknown // To distribute `BaseType` when it's a union type.
+ ? Simplify<
 // Pick just the keys that are readonly from the base type.
 Except<BaseType, Keys> & 
 // Pick the keys that should be mutable from the base type and make them mutable.
-Partial<Pick<BaseType, Keys>>>;
+Partial<HomomorphicPick<BaseType, Keys>>> : never;
 type PresetConfig = {
 	/**
 	 * Whether types should be imported or generated inline.

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,SAAQ,cAAgC;AACxC,SAAQ,iBAAgB;AACxB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAOK","sourcesContent":["export {preset, type PresetConfig} from './preset.js';\nexport {getSchema} from './schema.js';\nexport {\n  plugin,\n  pluckConfig,\n  processSources,\n  type GenericVariables,\n  type EmptyVariables,\n  type ClientReturn,\n  type IsOptionalVariables,\n  type ClientVariables,\n  type ClientVariablesInRestParams,\n} from '@shopify/graphql-codegen';\n"]}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,SAAQ,cAAgC;AACxC,SAAQ,iBAAgB;AACxB;AAAA,EAOE;AAAA,EACA;AAAA,EACA;AAAA,OACK","sourcesContent":["export {preset, type PresetConfig} from './preset.js';\nexport {getSchema} from './schema.js';\nexport {\n  type ClientReturn,\n  type ClientVariables,\n  type ClientVariablesInRestParams,\n  type EmptyVariables,\n  type GenericVariables,\n  type IsOptionalVariables,\n  pluckConfig,\n  plugin,\n  processSources,\n} from '@shopify/graphql-codegen';\n"]}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@shopify/hydrogen-codegen",
+  "description": "A codegen plugin and preset for generating TypeScript types from GraphQL queries in a `d.ts` file.",
   "publishConfig": {
     "access": "public",
     "@shopify:registry": "https://registry.npmjs.org"
   },
-  "version": "0.3.2",
+  "version": "0.3.3",
   "license": "MIT",
   "type": "module",
   "main": "dist/cjs/index.cjs",
@@ -29,7 +30,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/shopify/hydrogen.git",
+    "url": "https://github.com/Shopify/hydrogen.git",
     "directory": "packages/hydrogen-codegen"
   },
   "files": [