feat: Rename PropertyInfo#partial to #optional

pavadeli · pavadeli · commit 3f22b88c1125 · 2024-10-09T14:10:48.000+02:00
BREAKING CHANGE: `ObjectType#propsInfo` elements had a `partial` property. This is renamed to `optional`, because that better reflects its meaning.
diff --git a/src/interfaces.ts b/src/interfaces.ts
@@ -232,7 +232,7 @@ export type Properties = Record<string, Type<any>>;
  * Information about a single property of an object-like type including its optionality.
  */
 export type PropertyInfo<T extends Type<unknown> = Type<unknown>> = {
-    partial: boolean;
+    optional: boolean;
     type: T;
 };
 
diff --git a/src/types/interface.test.ts b/src/types/interface.test.ts
@@ -114,7 +114,7 @@ describe(object, () => {
     testTypes('type of keys and props', () => {
         const { keys, props, propsInfo } = MyType;
         assignableTo<{ s: typeof string; n: typeof number }>(props);
-        assignableTo<{ s: { partial: boolean; type: typeof string }; n: { partial: boolean; type: typeof number } }>(propsInfo);
+        assignableTo<{ s: { optional: boolean; type: typeof string }; n: { optional: boolean; type: typeof number } }>(propsInfo);
         assignableTo<typeof props>({ n: number, s: string });
         assignableTo<ReadonlyArray<'s' | 'n'>>(keys);
         assignableTo<typeof keys>(['s', 'n']);
@@ -139,9 +139,9 @@ describe(object, () => {
             expect(MyTypeWithOptional.name).toBe('{ s: string, n?: number, b?: boolean }');
             expect(MyTypeWithOptional.props).toStrictEqual({ s: string, n: number, b: boolean });
             expect(MyTypeWithOptional.propsInfo).toStrictEqual({
-                s: { type: string, partial: false },
-                n: { type: number, partial: true },
-                b: { type: boolean, partial: true },
+                s: { type: string, optional: false },
+                n: { type: number, optional: true },
+                b: { type: boolean, optional: true },
             });
 
             const Alternative = MyType.mergeWith(partial({ n: number, b: boolean }));
@@ -188,14 +188,14 @@ describe(object, () => {
             assignableTo<{ s: typeof string; n: typeof number }>(props);
             assignableTo<typeof props>({ n: number, s: string, b: boolean });
             assignableTo<{
-                s: { partial: boolean; type: typeof string };
-                n: { partial: boolean; type: typeof number };
-                b: { partial: boolean; type: typeof boolean };
+                s: { optional: boolean; type: typeof string };
+                n: { optional: boolean; type: typeof number };
+                b: { optional: boolean; type: typeof boolean };
             }>(propsInfo);
             assignableTo<typeof propsInfo>({
-                s: { partial: false, type: string },
-                n: { partial: false, type: number },
-                b: { partial: true, type: boolean },
+                s: { optional: false, type: string },
+                n: { optional: false, type: number },
+                b: { optional: true, type: boolean },
             });
             assignableTo<MyTypeWithOptional>({ s: 'asdf' });
             assignableTo<MyTypeWithOptional>({ n: 123, s: 'asdf' });
diff --git a/src/types/interface.ts b/src/types/interface.ts
@@ -147,7 +147,7 @@ export class InterfaceType<Props extends Properties, ResultType>
         const { strictMissingKeys } = this.options;
         const constructResult: Record<string, unknown> = {};
         const details: MessageDetails[] = [];
-        for (const [key, { type: innerType, partial }] of this.propsArray) {
+        for (const [key, { type: innerType, optional: partial }] of this.propsArray) {
             const missingKey = !hasOwnProperty(input, key);
             if (partial) {
                 if (missingKey || (!strictMissingKeys && input[key] === undefined)) {
@@ -282,8 +282,8 @@ define(InterfaceType, 'basicType', 'object');
 define(InterfaceType, 'createAutoCastAllType', function (this: InterfaceType<Properties, any>) {
     const name = extensionName(this, 'autoCastAll');
     const props: PropertiesInfo = {};
-    for (const [key, { type, partial }] of this.propsArray) {
-        props[key] = { type: type.autoCastAll, partial };
+    for (const [key, { type, optional: partial }] of this.propsArray) {
+        props[key] = { type: type.autoCastAll, optional: partial };
     }
     return createType(new InterfaceType(props, { ...this.options, name }).autoCast);
 });
@@ -322,21 +322,21 @@ export function partial<Props extends Properties>(
     return createType(new InterfaceType(toPropsInfo(props, true), options));
 }
 
-function toPropsInfo<Props extends Properties>(props: Props, partial: boolean): PropertiesInfo<Props> {
-    const genericPropsInfo: PropertiesInfo = mapValues(props, type => ({ type, partial }));
+function toPropsInfo<Props extends Properties>(props: Props, optional: boolean): PropertiesInfo<Props> {
+    const genericPropsInfo: PropertiesInfo = mapValues(props, type => ({ type, optional }));
     return genericPropsInfo as PropertiesInfo<Props>;
 }
 
-function getPossibleDiscriminators([key, { type, partial }]: [
+function getPossibleDiscriminators([key, { type, optional }]: [
     string,
     PropertyInfo<Type<unknown> | ObjectType<unknown>>,
 ]): PossibleDiscriminator[] {
-    if (!partial && 'possibleDiscriminators' in type) {
+    if (!optional && 'possibleDiscriminators' in type) {
         return type.possibleDiscriminators.map(({ path, values }) => ({ path: [key, ...path], values }));
     }
     if (type.enumerableLiteralDomain) {
         const values = [...type.enumerableLiteralDomain];
-        if (partial && !values.includes(undefined)) values.push(undefined);
+        if (optional && !values.includes(undefined)) values.push(undefined);
         return [{ path: [key], values }];
     }
     return [];
diff --git a/src/types/intersection.test.ts b/src/types/intersection.test.ts
@@ -134,14 +134,14 @@ describe(intersection, () => {
         assignableTo<{ a: typeof number; b: typeof number; c: typeof boolean }>(props);
         assignableTo<typeof props>({ a: number, b: number, c: boolean });
         assignableTo<{
-            a: { partial: boolean; type: typeof number };
-            b: { partial: boolean; type: typeof number };
-            c: { partial: boolean; type: typeof boolean };
+            a: { optional: boolean; type: typeof number };
+            b: { optional: boolean; type: typeof number };
+            c: { optional: boolean; type: typeof boolean };
         }>(propsInfo);
         assignableTo<typeof propsInfo>({
-            a: { partial: false, type: number },
-            b: { partial: false, type: number },
-            c: { partial: false, type: boolean },
+            a: { optional: false, type: number },
+            b: { optional: false, type: number },
+            c: { optional: false, type: boolean },
         });
     });
 });
diff --git a/src/types/intersection.ts b/src/types/intersection.ts
@@ -147,7 +147,7 @@ function combinedName(types: readonly BaseObjectLikeTypeImpl<unknown>[]) {
     const collectedProps: PropertiesInfo = {};
     for (const { propsInfo } of types) {
         for (const [key, prop] of Object.entries(propsInfo)) {
-            if (!collectedProps[key] || (collectedProps[key]?.partial && !prop.partial)) {
+            if (!collectedProps[key] || (collectedProps[key]?.optional && !prop.optional)) {
                 collectedProps[key] = prop;
             }
         }
diff --git a/src/types/union.ts b/src/types/union.ts
@@ -132,11 +132,11 @@ function analyzePropsInfo<Types extends OneOrMore<BaseTypeImpl<unknown> | BaseOb
     for (const nextType of rest) {
         if ('propsInfo' in nextType) {
             for (const [missingKey, propInfo] of Object.entries(result).filter(([key]) => !(key in nextType.propsInfo))) {
-                propInfo.partial || (result[missingKey] = { ...propInfo, partial: true });
+                propInfo.optional || (result[missingKey] = { ...propInfo, optional: true });
             }
             for (const [key, { type }] of Object.entries(nextType.propsInfo)) {
                 const existing = result[key];
-                result[key] = { partial: existing?.partial ?? true, type: existing?.type.or(type) ?? type };
+                result[key] = { optional: existing?.optional ?? true, type: existing?.type.or(type) ?? type };
             }
         } else {
             return {};
diff --git a/src/utils/print-utils.ts b/src/utils/print-utils.ts
@@ -157,7 +157,7 @@ export function defaultObjectRep(propsInfo: PropertiesInfo): string {
         return '{}';
     }
 
-    return `{ ${props.map(([key, { partial, type }]) => `${printKey(key)}${partial ? '?' : ''}: ${type.name}`).join(', ')} }`;
+    return `{ ${props.map(([key, { optional: partial, type }]) => `${printKey(key)}${partial ? '?' : ''}: ${type.name}`).join(', ')} }`;
 }
 
 export function bracketsIfNeeded(name: string, allowedSeparator?: '|' | '&'): string {

Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ function combinedName(types: readonly BaseObjectLikeTypeImpl<unknown>[]) {`
`147`	`147`	`const collectedProps: PropertiesInfo = {};`
`148`	`148`	`for (const { propsInfo } of types) {`
`149`	`149`	`for (const [key, prop] of Object.entries(propsInfo)) {`
`150`		`- if (!collectedProps[key] \|\| (collectedProps[key]?.partial && !prop.partial)) {`
	`150`	`+ if (!collectedProps[key] \|\| (collectedProps[key]?.optional && !prop.optional)) {`
`151`	`151`	`collectedProps[key] = prop;`
`152`	`152`	`}`
`153`	`153`	`}`
Original file line number	Diff line number	Diff line change
`@@ -132,11 +132,11 @@ function analyzePropsInfo<Types extends OneOrMore<BaseTypeImpl<unknown> \| BaseOb`
`132`	`132`	`for (const nextType of rest) {`
`133`	`133`	`if ('propsInfo' in nextType) {`
`134`	`134`	`for (const [missingKey, propInfo] of Object.entries(result).filter(([key]) => !(key in nextType.propsInfo))) {`
`135`		`- propInfo.partial \|\| (result[missingKey] = { ...propInfo, partial: true });`
	`135`	`+ propInfo.optional \|\| (result[missingKey] = { ...propInfo, optional: true });`
`136`	`136`	`}`
`137`	`137`	`for (const [key, { type }] of Object.entries(nextType.propsInfo)) {`
`138`	`138`	`const existing = result[key];`
`139`		`- result[key] = { partial: existing?.partial ?? true, type: existing?.type.or(type) ?? type };`
	`139`	`+ result[key] = { optional: existing?.optional ?? true, type: existing?.type.or(type) ?? type };`
`140`	`140`	`}`
`141`	`141`	`} else {`
`142`	`142`	`return {};`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ export function defaultObjectRep(propsInfo: PropertiesInfo): string {`
`157`	`157`	`return '{}';`
`158`	`158`	`}`
`159`	`159`
`160`		- return `{ ${props.map(([key, { partial, type }]) => `${printKey(key)}${partial ? '?' : ''}: ${type.name}`).join(', ')} }`;
	`160`	+ return `{ ${props.map(([key, { optional: partial, type }]) => `${printKey(key)}${partial ? '?' : ''}: ${type.name}`).join(', ')} }`;
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`export function bracketsIfNeeded(name: string, allowedSeparator?: '\|' \| '&'): string {`