@jarenjs/core 0.67.0 → 0.72.2

package/ARCHITECTURE.md

@@ -445,6 +445,7 @@ flowchart TB
         RegExpUtils --> IsRegExp["isRegExpType()"]
         RegExpUtils --> IsStringRegExp["isStringRegExp()<br/>(tests if valid pattern)"]
         RegExpUtils --> CreateRegExp["createRegExp()<br/>(handles /pattern/flags syntax)"]
+        RegExpUtils --> TestRegExp["createRegExpTester()<br/>(repeatable, isolated global/sticky state)"]
 
         Unicode["Unicode Support"]
         Unicode --> Ascii["isAsciiString()"]

package/README.md

@@ -11,7 +11,7 @@ None of it depends on JSON Schema: every module can be used standalone in any Ja
 | `@jarenjs/core` | type guards and getters (`isStringType`, `isObjectClass`, `getIntegerType`, ...) |
 | `@jarenjs/core/array` | array helpers (`isUniqueArray`, `getUniqueArray`, `includesAll`, ...) |
 | `@jarenjs/core/object` | deep equality (`equalsDeep`, JSON-only `equalsJson`), the `isJsonObject` and deep `isJsonValue` predicates, `__proto__`-safe `setObjectMember`, `deepFreeze`, map/set merging |
-| `@jarenjs/core/string` | Unicode string helpers (`countCodePoints`, `compareCodePoints`, ...), cached regex compilation, the suite's one content hash (`fnv1a` and the `hashContent` fingerprint over it) and `kebabCase` |
+| `@jarenjs/core/string` | Unicode string helpers (`countCodePoints`, `compareCodePoints`, ...), regex compilation and repeatable `createRegExpTester` predicates, the suite's one content hash (`fnv1a` and the `hashContent` fingerprint over it) and `kebabCase` |
 | `@jarenjs/core/cache` | the bounded LRU (`createBoundedCache`), the reference-keyed `createWeakCache`, and `createSemanticCache` — keyed by what a value IS, for caches whose entries decide a result |
 | `@jarenjs/core/random` | the suite's one seeded generator (`mulberry32`, pinned sequence, ToUint32 seed) and the draws built on it: `randomInt` over a half-open range, in-place Fisher–Yates `shuffle`, and `drawDistinct` — `k` distinct indices from one stream |
 | `@jarenjs/core/runtime` | the runtime record — `createRuntime({ now, uuid, random, zoneProvider })`, frozen, defaulting member for member to the platform's own (`Date.now`, `crypto.randomUUID`, `Math.random`, no zone provider) — that the store (its query deadlines included), the jobs engine, the migration runner, every contract binding and the contract memory ledger take as `runtime`, so a deterministic run is configured once; a subsystem's own explicit option wins over the record, and the record reaches hosts, never query compilation |
@@ -41,14 +41,16 @@ Deep imports work too (`@jarenjs/core/text/email`, `@jarenjs/core/math/vec2f64`,
 `@jarenjs/core/string` counts string length the way JSON Schema expects — by grapheme cluster, not UTF-16 code units — without paying for `Intl.Segmenter` unless the string actually needs it:
 
 ```javascript
-import { getStringLength, isAsciiString, createRegExp } from '@jarenjs/core/string';
+import { getStringLength, isAsciiString, createRegExp, createRegExpTester } from '@jarenjs/core/string';
 
 getStringLength('hello', true);       // 5  (ASCII fast path: str.length)
 getStringLength('héllo', true);       // 5  (surrogate-aware code point count)
 getStringLength('👨‍👩‍👧‍👦', true); // 1  (grapheme segmentation, only when clusters can form)
 getStringLength('👨‍👩‍👧‍👦');       // 11 (default: plain UTF-16 length)
 
-createRegExp('^\\p{L}+$');            // cached, unicode-flagged RegExp
+createRegExp('^\\p{L}+$');            // unicode-flagged RegExp
+const matches = createRegExpTester('/^x/gi');
+matches('X'); matches('X');          // true both times; global/sticky state is isolated
 ```
 
 ## Text validation
@@ -88,7 +90,7 @@ orient2d(0, 0, 1, 0, 0, 1);                    // > 0 — counter-clockwise, exa
 haversineDistance(4.9041, 52.3676, 2.3522, 48.8566); // 429_862 m (Amsterdam–Paris)
 ringWinding([[0,0],[1,0],[1,1],[0,1],[0,0]]);  // 1 — an RFC 7946 exterior ring
 bboxOf({ type: 'Polygon', coordinates: [[[4,52],[5,52],[5,53],[4,52]]] }); // [4, 52, 5, 53]
-geohashEncode(4.9041, 52.3676, 5);             // 'u173z' — a string, so a prefix test is proximity
+geohashEncode(4.9041, 52.3676, 5);             // 'u173z' — a string identifying a cell; use distances for proximity
 
 wktToGeoJson('POINT (4.9041 52.3676)');        // { type: 'Point', coordinates: [4.9041, 52.3676] }
 geoJsonToWkt({ type: 'Point', coordinates: [4.9041, 52.3676] }); // 'POINT (4.9041 52.3676)'
@@ -179,6 +181,7 @@ The kernel is measured against one-pass loops written for one question and again
 import { compileMessageTemplate, compileMessageCatalog } from '@jarenjs/core/message';
 
 const t = compileMessageTemplate('must be {comparison} {limit}');
+// t.parameters is the frozen unique list ['comparison', 'limit'] from this parser.
 t({ comparison: '>=', limit: 18 });   // 'must be >= 18'
 ```
 

package/dist/types/message.d.ts

@@ -38,9 +38,11 @@ export declare function formatMessageValue(value: unknown): string;
  * instead of rendering as `undefined`); `{{` escapes a literal `{`.
  *
  * @param {string} template - The template text
- * @returns {(params: object, error?: object) => string} The compiled render closure
+ * @returns {((params: object, error?: object) => string) & { readonly parameters: readonly string[] }} The compiled render closure and its unique placeholder names
  */
-export declare function compileMessageTemplate(template: string): (params: object, error?: object) => string;
+export declare function compileMessageTemplate(template: string): ((params: object, error?: object) => string) & {
+    readonly parameters: readonly string[];
+};
 /**
  * Compile a catalog-like object into a functions-only frozen catalog.
  * Entries may be render closures (kept as-is) or template strings

package/dist/types/string.d.ts

@@ -33,6 +33,13 @@ export declare function isStringRegExp(data: string | RegExp | null | undefined)
  * @returns {RegExp | undefined}
  */
 export declare function createRegExp(pattern: string | RegExp | null | undefined): RegExp | undefined;
+/**
+ * Compile a pattern into a repeatable predicate. Global and sticky patterns
+ * start at index zero on every call and never change a caller's RegExp state.
+ * @param {string | RegExp | null | undefined} pattern - The regular expression
+ * @returns {((value: string) => boolean) | undefined} The tester, or undefined when no pattern was supplied
+ */
+export declare function createRegExpTester(pattern: string | RegExp | null | undefined): ((value: string) => boolean) | undefined;
 export declare function getSegmenter(): Intl.Segmenter;
 /**
  * @param {string} str

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jarenjs/core",
   "private": false,
-  "version": "0.67.0",
+  "version": "0.72.2",
   "type": "module",
   "main": "./src/index.js",
   "types": "./dist/types/index.d.ts",

package/src/message.js

@@ -1,4 +1,5 @@
 //@ts-check
+import { setObjectMember } from './object.js';
 
 /**
  * Human-message templating: the shared half of every message catalog in
@@ -49,7 +50,7 @@ export function formatMessageValue(value) {
  * instead of rendering as `undefined`); `{{` escapes a literal `{`.
  *
  * @param {string} template - The template text
- * @returns {(params: object, error?: object) => string} The compiled render closure
+ * @returns {((params: object, error?: object) => string) & { readonly parameters: readonly string[] }} The compiled render closure and its unique placeholder names
  */
 export function compileMessageTemplate(template) {
   /** @type {string[]} literal parts between placeholders */
@@ -79,22 +80,24 @@ export function compileMessageTemplate(template) {
   }
   parts.push(literal);
 
-  if (names.length === 0) {
-    const text = parts[0];
-    return function renderLiteralTemplate() { return text; };
-  }
-
-  return function renderMessageTemplate(params) {
-    let out = parts[0];
-    for (let i = 0; i < names.length; ++i) {
-      const name = names[i];
-      out += (params != null && name in params)
-        ? formatTemplateParam(params[name])
-        : `{${name}}`;
-      out += parts[i + 1];
-    }
-    return out;
-  };
+  const render = names.length === 0
+    ? function renderLiteralTemplate() { return parts[0]; }
+    : function renderMessageTemplate(params) {
+      let out = parts[0];
+      for (let i = 0; i < names.length; ++i) {
+        const name = names[i];
+        out += (params != null && name in params)
+          ? formatTemplateParam(params[name])
+          : `{${name}}`;
+        out += parts[i + 1];
+      }
+      return out;
+    };
+  // Metadata comes from the parser that renders the message; consumers must
+  // never parse placeholders with a second, subtly different grammar.
+  return Object.defineProperty(render, 'parameters', {
+    value: Object.freeze([...new Set(names)]), enumerable: true,
+  });
 }
 
 /**
@@ -111,9 +114,9 @@ export function compileMessageCatalog(catalogLike) {
   const keys = Object.keys(catalogLike);
   for (let i = 0; i < keys.length; ++i) {
     const entry = catalogLike[keys[i]];
-    compiled[keys[i]] = typeof entry === 'function'
+    setObjectMember(compiled, keys[i], typeof entry === 'function'
       ? entry
-      : compileMessageTemplate(String(entry));
+      : compileMessageTemplate(String(entry)));
   }
   return Object.freeze(compiled);
 }

package/src/string.js

@@ -88,6 +88,24 @@ export function createRegExp(pattern) {
   throw new Error(`Unknown Regular Expression Pattern Type: ${pattern}`);
 }
 
+/**
+ * Compile a pattern into a repeatable predicate. Global and sticky patterns
+ * start at index zero on every call and never change a caller's RegExp state.
+ * @param {string | RegExp | null | undefined} pattern - The regular expression
+ * @returns {((value: string) => boolean) | undefined} The tester, or undefined when no pattern was supplied
+ */
+export function createRegExpTester(pattern) {
+  const parsed = createRegExp(pattern);
+  if (parsed === undefined) return undefined;
+  if (!parsed.global && !parsed.sticky)
+    return (value) => parsed.test(value);
+  const owned = new RegExp(parsed.source, parsed.flags);
+  return (value) => {
+    owned.lastIndex = 0;
+    return owned.test(value);
+  };
+}
+
 /**
  * @type {Intl.Segmenter | null}
  */