@sealcode/sealgen 0.15.32 → 0.15.34

package/@types/src/page/mountable-with-fields.d.ts

@@ -11,6 +11,7 @@ export type PageErrorMessage = {
 };
 export type Fields = Record<string, FormField<boolean, any>>;
 type Resolved<T> = T extends Promise<infer X> ? X : never;
+type ParsedValue<T extends FormField> = Resolved<ReturnType<T["getValue"]>>["parsed"];
 export declare abstract class MountableWithFields<F extends Fields = Fields> extends Mountable {
     fields: F;
     field_names_prefix: string;
@@ -34,7 +35,7 @@ export declare abstract class MountableWithFields<F extends Fields = Fields> ext
     renderMessages(_: Context, data: FormData<keyof Fields>): FlatTemplatable;
     abstract extractRawValues(ctx: Context): Promise<Record<string, FormDataValue>>;
     getParsedValues(ctx: Context): Promise<{
-        [field in keyof F]: Resolved<ReturnType<F[field]["getValue"]>>["parsed"];
+        [field in keyof F]: F[field] extends FormField<true> ? Exclude<ParsedValue<F[field]>, null> : ParsedValue<F[field]>;
     }>;
     getDatabaseValues(ctx: Context): Promise<ShapeToType<FieldsToShape<F>>>;
 }

package/@types/src/utils/utils.d.ts

@@ -14,3 +14,4 @@ export * from "./make-slug.js";
 export * from "./render-attributes.js";
 export * from "./format-external-url.js";
 export * from "./base64.js";
+export * from "./with-fallback.js";

package/@types/src/utils/with-fallback.d.ts

@@ -0,0 +1,2 @@
+export declare function withFallback<T1, T2 extends NonNullable<unknown>>(value1: T1, value2: T2): NonNullable<T1> | T2;
+export declare function withFallback<T1, T2, T3 extends NonNullable<unknown>>(value1: T1, value2: T2, value3?: T3): NonNullable<T1> | NonNullable<T2> | T3;

package/lib/page/mountable-with-fields.test.js

@@ -2,8 +2,11 @@ import { Form } from "../forms/form.js";
 import { FieldTypes } from "sealious";
 import { CollectionField } from "../forms/fields/collection-field.js";
 describe("mountable-with-fields", () => {
-  it("properly types the getParsedValues method", () => {
-    const fields = { name: new CollectionField(true, new FieldTypes.Text()) };
+  it("properly types the getParsedValues method and respects required status", () => {
+    const fields = {
+      not_required: new CollectionField(false, new FieldTypes.Text()),
+      required: new CollectionField(true, new FieldTypes.Text())
+    };
     new class extends Form {
       constructor() {
         super(...arguments);
@@ -12,8 +15,9 @@ describe("mountable-with-fields", () => {
       }
       async onSubmit(ctx, form_values) {
         const data = await this.getParsedValues(ctx);
-        data.name?.trim();
-        const { parsed: data2 } = await this.fields.name.getValue(
+        data.not_required?.trim();
+        data.required.trim();
+        const { parsed: data2 } = await this.fields.not_required.getValue(
           ctx,
           form_values.raw_values
         );

package/lib/utils/utils.js

@@ -13,6 +13,7 @@ export * from "./make-slug.js";
 export * from "./render-attributes.js";
 export * from "./format-external-url.js";
 export * from "./base64.js";
+export * from "./with-fallback.js";
 export {
   UrlWithNewParams,
   assertThrowsAsync,

package/lib/utils/with-fallback.js

@@ -0,0 +1,21 @@
+function withFallback(value1, value2, value3) {
+  if (value3 !== void 0) {
+    if (value1 !== null && value1 !== void 0 && value2 !== null && value2 !== void 0) {
+      return value2;
+    } else {
+      return value3;
+    }
+  } else {
+    if (value1 !== null && value1 !== void 0) {
+      return value1;
+    } else if (value2 !== void 0 && value2 !== null) {
+      return value2;
+    } else {
+      throw new Error("No suitable fallback: ${arguments}");
+    }
+  }
+}
+export {
+  withFallback
+};
+//# sourceMappingURL=with-fallback.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sealcode/sealgen",
-	"version": "0.15.32",
+	"version": "0.15.34",
 	"description": "Module to automate adding routes and collections to a sealious application",
 	"main": "lib/index.js",
 	"type": "module",

package/src/page/mountable-with-fields.test.ts

@@ -5,16 +5,21 @@ import { CollectionField } from "../forms/fields/collection-field.js";
 import { FormData } from "../forms/form-types.js";
 
 describe("mountable-with-fields", () => {
-	it("properly types the getParsedValues method", () => {
-		const fields = { name: new CollectionField(true, new FieldTypes.Text()) };
+	it("properly types the getParsedValues method and respects required status", () => {
+		const fields = {
+			not_required: new CollectionField(false, new FieldTypes.Text()),
+			required: new CollectionField(true, new FieldTypes.Text()),
+		};
 		new (class extends Form<typeof fields, void> {
 			fields = fields;
 			controls = [];
 			async onSubmit(ctx: Context, form_values: FormData) {
 				const data = await this.getParsedValues(ctx);
 				// this should not throw a Typescript error
-				data.name?.trim();
-				const { parsed: data2 } = await this.fields.name.getValue(
+				data.not_required?.trim();
+				// this should work without the optional chaining:
+				data.required.trim();
+				const { parsed: data2 } = await this.fields.not_required.getValue(
 					ctx,
 					form_values.raw_values
 				);

package/src/page/mountable-with-fields.ts

@@ -19,6 +19,9 @@ export type PageErrorMessage = { type: "access" | "internal"; message: string };
 export type Fields = Record<string, FormField<boolean, any>>;
 
 type Resolved<T> = T extends Promise<infer X> ? X : never;
+type ParsedValue<T extends FormField> = Resolved<
+	ReturnType<T["getValue"]>
+>["parsed"];
 
 export abstract class MountableWithFields<
 	F extends Fields = Fields
@@ -137,9 +140,9 @@ export abstract class MountableWithFields<
 	): Promise<Record<string, FormDataValue>>;
 
 	async getParsedValues(ctx: Context): Promise<{
-		[field in keyof F]: Resolved<
-			ReturnType<F[field]["getValue"]>
-		>["parsed"];
+		[field in keyof F]: F[field] extends FormField<true>
+			? Exclude<ParsedValue<F[field]>, null>
+			: ParsedValue<F[field]>;
 	}> {
 		const raw_values = await this.extractRawValues(ctx);
 		const result: Record<string, unknown> = {};
@@ -151,7 +154,9 @@ export abstract class MountableWithFields<
 			}
 		);
 		await Promise.all(promises);
-		return result as ShapeToType<FieldsToShape<F>>;
+		// TODO: remove this any. I don't have the strenght to deal with it now.
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
+		return result as any;
 	}
 
 	async getDatabaseValues(

package/src/utils/utils.ts

@@ -23,3 +23,4 @@ export * from "./make-slug.js";
 export * from "./render-attributes.js";
 export * from "./format-external-url.js";
 export * from "./base64.js";
+export * from "./with-fallback.js";

package/src/utils/with-fallback.ts

@@ -0,0 +1,47 @@
+// use this to more concisely define values with one or more fallbacks to use when they are null.
+
+// If called with two args, the second one has to be non-null
+// if called with three args, the third one has to be non-null
+//
+// in two-arg mode, if the first argument is not null, then it's returned and fallback is not used.
+//                  if the first argument is null, then the second arg is returned
+//
+// in three-arg mode, the first value is never returned. If the first arg is not-null, then the second arg is returned (if it's not null). Otherwise the third arg is returned
+
+export function withFallback<T1, T2 extends NonNullable<unknown>>(
+	value1: T1,
+	value2: T2
+): NonNullable<T1> | T2;
+export function withFallback<T1, T2, T3 extends NonNullable<unknown>>(
+	value1: T1,
+	value2: T2,
+	value3?: T3
+): NonNullable<T1> | NonNullable<T2> | T3;
+export function withFallback<T1, T2, T3 extends NonNullable<unknown>>(
+	value1: T1,
+	value2: T2,
+	value3?: T3
+): NonNullable<T1> | NonNullable<T2> | T3 {
+	if (value3 !== undefined) {
+		// three arg mode
+		if (
+			value1 !== null &&
+			value1 !== undefined &&
+			value2 !== null &&
+			value2 !== undefined
+		) {
+			return value2;
+		} else {
+			return value3;
+		}
+	} else {
+		// two arg mode
+		if (value1 !== null && value1 !== undefined) {
+			return value1;
+		} else if (value2 !== undefined && value2 !== null) {
+			return value2;
+		} else {
+			throw new Error("No suitable fallback: ${arguments}");
+		}
+	}
+}