kopular 0.12.0 → 0.13.0

package/LLM.md

@@ -365,9 +365,20 @@ email.Valid();                  // bool — Error.Value == null
 **No array-of-validators parameter** — KopScript has no array-of-function-values type
 (`((T) => string?)[]` doesn't parse: the parser reads a second `(...)  => ...` immediately
 after the first as a nested function type, not an array element type, and errors expecting
-`=>`). Combine checks as an if-chain in one lambda instead (see the `email` example above)
-— this is the same reason `FormField<T>`'s constructor takes exactly one validator
-function, not a list.
+`=>`). Combine checks as an if-chain in one lambda (see the `email` example above), or via
+the fixed-arity `CombineValidators2<T>`/`CombineValidators3<T>` free functions (generic,
+inference-only — see `Kop`'s own "Generics" docs for why they're *free* functions, not
+`Validators` static methods):
+```ks
+CombineValidators2((string v) => Validators.Required(v), (string v) => Validators.Email(v))
+// -> a single (string) => string? — Required first, Email only if that passes
+```
+Fixed-arity (2, 3 — add more the same way if a form ever needs to chain further), not a
+general `Validators.All(...)`, for the same array-of-function-values reason above.
+
+**No DOM binding** — wiring `.Value` to a real `<input>` is a plain `addEventListener`
+call in your own `Render()`, the same as any other event handler; there is no
+`[(ngModel)]`-equivalent.
 
 **No DOM binding** — wiring `.Value` to a real `<input>` is a plain `addEventListener`
 call in your own `Render()`, the same as any other event handler; there is no

package/README.md

@@ -447,10 +447,21 @@ constructor exactly like `Counter`'s own `state<number>`, to re-render when they
 A validator is a plain `(T) => string?` — `null` means valid, the same convention
 KopScript's own nullable types use elsewhere. **There's no array-of-validators
 constructor parameter** — KopScript has no syntax for an array of function values — so
-combining more than one check (as `email` does above) is just an `if`-chain in one
-lambda, not a combinator API. `Validators` ships the handful of checks almost every form
-needs (`Required`, `MinLength`, `MaxLength`, `Email`, `Min`, `Max`), each returning its
-own message; write your own validator function for anything more specific.
+combining more than one check (as `email` does above) is an `if`-chain in one lambda, or,
+for the common case of just chaining a couple of already-built validators with no custom
+logic of their own, the `CombineValidators2`/`CombineValidators3` free functions:
+
+```ks
+FormField<string> email = new FormField<string>("",
+  CombineValidators2((string v) => Validators.Required(v), (string v) => Validators.Email(v)));
+```
+
+Free functions, not `Validators` methods, and fixed-arity (2 and 3) rather than a general
+`Validators.All(...)` — a class's own static method can't introduce a new type parameter
+beyond the class's own (see "Generics" in `Kop`'s own docs), so a *generic* combinator has
+to live as a free function instead. `Validators` ships the handful of checks almost every
+form needs (`Required`, `MinLength`, `MaxLength`, `Email`, `Min`, `Max`), each returning
+its own message; write your own validator function for anything more specific.
 
 **No two-way data binding** — wiring `Value` to a real `<input>` is the
 `addEventListener` call shown above, the same manual pattern `Counter` already uses for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kopular",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Kopular: a small component framework for KopScript — components, reactive state, constructor-injected services, routing, real compiled templates, and HTTP, with no DI container",
   "type": "module",
   "license": "MIT",

package/src/forms.js

@@ -13,6 +13,28 @@ class __KopState {
   }
 }
 
+export function CombineValidators2(v1, v2) {
+  return (value) => {
+  let r1 = v1(value);
+  if ((r1 !== null)) {
+    return r1;
+  }
+  return v2(value);
+};
+}
+export function CombineValidators3(v1, v2, v3) {
+  return (value) => {
+  let r1 = v1(value);
+  if ((r1 !== null)) {
+    return r1;
+  }
+  let r2 = v2(value);
+  if ((r2 !== null)) {
+    return r2;
+  }
+  return v3(value);
+};
+}
 export class FormField {
   constructor(initial, validate) {
     this.Value = new __KopState(initial);

package/src/forms.js.map

@@ -1 +1 @@
-{"version":3,"file":"forms.js","sources":["forms.ks"],"sourcesContent":["// FormField<T>: a single form input's value, validation state, and touched\n// flag, built on the same state<T> reactivity Component already uses — no\n// new reactive primitive, and deliberately no DOM binding of its own\n// (wiring Value to a real <input> is one addEventListener call in your own\n// Render(), the same as Counter's own click handler — see Kopular's README).\n//\n// A validator is a plain (T) => string? function: null means valid, the\n// same \"null means nothing to report\" convention KopScript's nullable\n// types already use elsewhere. There's no array of validators — KopScript\n// has no syntax for an array of function values — so combining more than\n// one check is just an if-chain in one lambda:\n//\n//   FormField<string> name = new FormField<string>(\"\", (string v) => {\n//     string? required = Validators.Required(v);\n//     if (required != null) { return required; }\n//     return Validators.MaxLength(v, 40);\n//   });\nclass FormField<T> {\n  public state<T> Value;\n  public state<string?> Error;\n  public state<bool> Touched;\n\n  constructor(T initial, (T) => string? validate) {\n    this.Value = state(initial);\n    this.Error = state(validate(initial));\n    this.Touched = state(false);\n    this.Value.Subscribe((T v) => { this.Error.Value = validate(v); });\n  }\n\n  // Call on blur — separate from Error so a fresh, untouched field with an\n  // invalid initial value (e.g. Required on an empty string) doesn't show\n  // an error message before the user has had a chance to type anything.\n  public void Touch() {\n    this.Touched.Value = true;\n  }\n\n  public bool Valid() {\n    return this.Error.Value == null;\n  }\n}\n\n// A small set of common checks, each returning an error message or null —\n// not a validation framework, just the handful of checks almost every form\n// needs, so most fields don't have to hand-write string-length arithmetic.\nclass Validators {\n  public static string? Required(string value) {\n    if (value.Trim().Length == 0) { return \"Required\"; }\n    return null;\n  }\n\n  public static string? MinLength(string value, number min) {\n    if (value.Length < min) { return $\"Must be at least {min} characters\"; }\n    return null;\n  }\n\n  public static string? MaxLength(string value, number max) {\n    if (value.Length > max) { return $\"Must be at most {max} characters\"; }\n    return null;\n  }\n\n  public static string? Email(string value) {\n    return match value {\n      r\"^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$\" => null,\n      _ => \"Must be a valid email\"\n    };\n  }\n\n  public static string? Min(number value, number min) {\n    if (value < min) { return $\"Must be at least {min}\"; }\n    return null;\n  }\n\n  public static string? Max(number value, number max) {\n    if (value > max) { return $\"Must be at most {max}\"; }\n    return null;\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;AAiBA;EAKE;IACa;IACA;IACE;IACO;EAA6B;;;;EAM5C;IACc;;;EAGd;IACL;;;AAOJ;EACgB;IACZ;MAAgC;;IAChC;;;EAGY;IACZ;MAA0B;;IAC1B;;;EAGY;IACZ;MAA0B;;IAC1B;;;EAGY;IACZ;;EACE;;;EACA;;;;;;EAIU;IACZ;MAAmB;;IACnB;;;EAGY;IACZ;MAAmB;;IACnB"}
+{"version":3,"file":"forms.js","sources":["forms.ks"],"sourcesContent":["// FormField<T>: a single form input's value, validation state, and touched\n// flag, built on the same state<T> reactivity Component already uses — no\n// new reactive primitive, and deliberately no DOM binding of its own\n// (wiring Value to a real <input> is one addEventListener call in your own\n// Render(), the same as Counter's own click handler — see Kopular's README).\n//\n// A validator is a plain (T) => string? function: null means valid, the\n// same \"null means nothing to report\" convention KopScript's nullable\n// types already use elsewhere. There's no array of validators — KopScript\n// has no syntax for an array of function values — so combining more than\n// one check is either an if-chain in one lambda, hand-written:\n//\n//   FormField<string> name = new FormField<string>(\"\", (string v) => {\n//     string? required = Validators.Required(v);\n//     if (required != null) { return required; }\n//     return Validators.MaxLength(v, 40);\n//   });\n//\n// or the CombineValidators2/CombineValidators3 free functions below, for\n// the common case of just chaining a couple of already-built validators\n// with no custom logic of their own:\n//\n//   FormField<string> name = new FormField<string>(\"\",\n//     CombineValidators2((string v) => Validators.Required(v), (string v) => Validators.MaxLength(v, 40)));\n//\n// Free functions, not static Validators methods, and fixed-arity (2 and 3),\n// not a general array-taking Validators.All(...): KopScript has no\n// array-of-function-values type to accept a variable-length list with, and\n// a generic function can only be a *free* function in v1 — a class's own\n// static method can't introduce a new type parameter of its own beyond the\n// class's (Validators itself isn't generic) — see Kop's README/LLM.md\n// \"Generics\" section for exactly that cut. Add CombineValidators4 etc. the\n// same way if a real form ever needs to chain more than three.\n(T) => string? CombineValidators2<T>((T) => string? v1, (T) => string? v2) {\n  return (T value) => {\n    string? r1 = v1(value);\n    if (r1 != null) { return r1; }\n    return v2(value);\n  };\n}\n\n(T) => string? CombineValidators3<T>((T) => string? v1, (T) => string? v2, (T) => string? v3) {\n  return (T value) => {\n    string? r1 = v1(value);\n    if (r1 != null) { return r1; }\n    string? r2 = v2(value);\n    if (r2 != null) { return r2; }\n    return v3(value);\n  };\n}\nclass FormField<T> {\n  public state<T> Value;\n  public state<string?> Error;\n  public state<bool> Touched;\n\n  constructor(T initial, (T) => string? validate) {\n    this.Value = state(initial);\n    this.Error = state(validate(initial));\n    this.Touched = state(false);\n    this.Value.Subscribe((T v) => { this.Error.Value = validate(v); });\n  }\n\n  // Call on blur — separate from Error so a fresh, untouched field with an\n  // invalid initial value (e.g. Required on an empty string) doesn't show\n  // an error message before the user has had a chance to type anything.\n  public void Touch() {\n    this.Touched.Value = true;\n  }\n\n  public bool Valid() {\n    return this.Error.Value == null;\n  }\n}\n\n// A small set of common checks, each returning an error message or null —\n// not a validation framework, just the handful of checks almost every form\n// needs, so most fields don't have to hand-write string-length arithmetic.\nclass Validators {\n  public static string? Required(string value) {\n    if (value.Trim().Length == 0) { return \"Required\"; }\n    return null;\n  }\n\n  public static string? MinLength(string value, number min) {\n    if (value.Length < min) { return $\"Must be at least {min} characters\"; }\n    return null;\n  }\n\n  public static string? MaxLength(string value, number max) {\n    if (value.Length > max) { return $\"Must be at most {max} characters\"; }\n    return null;\n  }\n\n  public static string? Email(string value) {\n    return match value {\n      r\"^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$\" => null,\n      _ => \"Must be a valid email\"\n    };\n  }\n\n  public static string? Min(number value, number min) {\n    if (value < min) { return $\"Must be at least {min}\"; }\n    return null;\n  }\n\n  public static string? Max(number value, number max) {\n    if (value > max) { return $\"Must be at most {max}\"; }\n    return null;\n  }\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;AAiCA;EACE;EACE;EACA;IAAkB;;EAClB;;;AAIJ;EACE;EACE;EACA;IAAkB;;EAClB;EACA;IAAkB;;EAClB;;;AAGJ;EAKE;IACa;IACA;IACE;IACO;EAA6B;;;;EAM5C;IACc;;;EAGd;IACL;;;AAOJ;EACgB;IACZ;MAAgC;;IAChC;;;EAGY;IACZ;MAA0B;;IAC1B;;;EAGY;IACZ;MAA0B;;IAC1B;;;EAGY;IACZ;;EACE;;;EACA;;;;;;EAIU;IACZ;MAAmB;;IACnB;;;EAGY;IACZ;MAAmB;;IACnB"}

package/src/forms.ks

@@ -8,13 +8,46 @@
 // same "null means nothing to report" convention KopScript's nullable
 // types already use elsewhere. There's no array of validators — KopScript
 // has no syntax for an array of function values — so combining more than
-// one check is just an if-chain in one lambda:
+// one check is either an if-chain in one lambda, hand-written:
 //
 //   FormField<string> name = new FormField<string>("", (string v) => {
 //     string? required = Validators.Required(v);
 //     if (required != null) { return required; }
 //     return Validators.MaxLength(v, 40);
 //   });
+//
+// or the CombineValidators2/CombineValidators3 free functions below, for
+// the common case of just chaining a couple of already-built validators
+// with no custom logic of their own:
+//
+//   FormField<string> name = new FormField<string>("",
+//     CombineValidators2((string v) => Validators.Required(v), (string v) => Validators.MaxLength(v, 40)));
+//
+// Free functions, not static Validators methods, and fixed-arity (2 and 3),
+// not a general array-taking Validators.All(...): KopScript has no
+// array-of-function-values type to accept a variable-length list with, and
+// a generic function can only be a *free* function in v1 — a class's own
+// static method can't introduce a new type parameter of its own beyond the
+// class's (Validators itself isn't generic) — see Kop's README/LLM.md
+// "Generics" section for exactly that cut. Add CombineValidators4 etc. the
+// same way if a real form ever needs to chain more than three.
+(T) => string? CombineValidators2<T>((T) => string? v1, (T) => string? v2) {
+  return (T value) => {
+    string? r1 = v1(value);
+    if (r1 != null) { return r1; }
+    return v2(value);
+  };
+}
+
+(T) => string? CombineValidators3<T>((T) => string? v1, (T) => string? v2, (T) => string? v3) {
+  return (T value) => {
+    string? r1 = v1(value);
+    if (r1 != null) { return r1; }
+    string? r2 = v2(value);
+    if (r2 != null) { return r2; }
+    return v3(value);
+  };
+}
 class FormField<T> {
   public state<T> Value;
   public state<string?> Error;