stringent 0.0.2 → 0.0.4

package/package.json

@@ -1,11 +1,20 @@
 {
   "name": "stringent",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "A smart and type-safe expression parser",
   "keywords": [
     "parser",
     "expression",
-    "typescript"
+    "typescript",
+    "type-safe",
+    "compile-time",
+    "type-level",
+    "expression-parser",
+    "dsl",
+    "ast",
+    "grammar",
+    "validation",
+    "inference"
   ],
   "homepage": "https://github.com/formeddable/stringent#readme",
   "bugs": {
@@ -18,6 +27,9 @@
   "license": "MIT",
   "author": "Essam Almansouri",
   "type": "module",
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "files": [
     "dist"
   ],
@@ -29,10 +41,20 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "packageManager": "pnpm@10.28.1",
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
-    "test": "tsx src/test.ts",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"examples/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"examples/**/*.ts\"",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "bench": "vitest bench",
+    "docs": "typedoc",
+    "docs:watch": "typedoc --watch",
     "prepublishOnly": "pnpm build"
   },
   "dependencies": {
@@ -40,9 +62,18 @@
     "arktype": "^2.1.29"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.2",
     "@types/node": "^22.10.5",
+    "@vitest/coverage-v8": "^4.0.17",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
     "hotscript": "^1.0.13",
+    "prettier": "^3.8.0",
     "tsx": "^4.21.0",
-    "typescript": "^5.7.2"
+    "typedoc": "^0.28.16",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.53.0",
+    "vitest": "^4.0.17"
   }
 }

package/dist/combinators/index.d.ts

@@ -1,57 +0,0 @@
-/**
- * Parser Combinators
- *
- * Composable parsers that work at both runtime and compile-time.
- * Parse methods are generic - return types computed from input literals.
- * All combinators thread context ($) through to child parsers.
- *
- * IMPORTANT: All parse methods MUST be generic in context:
- *   parse<TInput extends string, $ extends Context>(input: TInput, $: $)
- */
-import type { Context } from "../context.js";
-import type { IParser, ParseNumber, ParseString, ParseIdent, ParseConst, _Number, _String, _Ident, _Const } from "../primitive/index.js";
-/** Static type for parsing any parser */
-export type Parse<P, TInput extends string, $ extends Context> = P extends _Number ? ParseNumber<TInput> : P extends _String<infer Q> ? ParseString<Q, TInput> : P extends _Const<infer V> ? ParseConst<V, TInput> : P extends _Ident ? ParseIdent<TInput, $> : P extends _Union<infer Parsers> ? ParseUnion<Parsers, TInput, $> : P extends _Tuple<infer Parsers> ? ParseTuple<Parsers, TInput, $> : P extends _Optional<infer Parser> ? ParseOptional<Parser, TInput, $> : P extends _Many<infer Parser> ? ParseMany<Parser, TInput, $> : never;
-/** Static type for Union parsing */
-export type ParseUnion<TParsers extends IParser[], TInput extends string, $ extends Context> = TParsers extends [
-    infer First extends IParser,
-    ...infer Rest extends IParser[]
-] ? Parse<First, TInput, $> extends [infer R, infer Remaining extends string] ? [R, Remaining] : ParseUnion<Rest, TInput, $> : [];
-/** Static type for Tuple parsing */
-export type ParseTuple<TParsers extends IParser[], TInput extends string, $ extends Context, TAcc extends unknown[] = []> = TParsers extends [
-    infer First extends IParser,
-    ...infer Rest extends IParser[]
-] ? Parse<First, TInput, $> extends [infer R, infer Remaining extends string] ? ParseTuple<Rest, Remaining, $, [...TAcc, R]> : [] : [TAcc, TInput];
-/** Static type for Optional parsing */
-export type ParseOptional<TParser extends IParser, TInput extends string, $ extends Context> = Parse<TParser, TInput, $> extends [infer R, infer Remaining extends string] ? [R, Remaining] : [undefined, TInput];
-/** Static type for Many parsing */
-export type ParseMany<TParser extends IParser, TInput extends string, $ extends Context, TAcc extends unknown[] = []> = Parse<TParser, TInput, $> extends [infer R, infer Remaining extends string] ? Remaining extends TInput ? [TAcc, TInput] : ParseMany<TParser, Remaining, $, [...TAcc, R]> : [TAcc, TInput];
-declare class _Union<TParsers extends IParser[]> {
-    readonly __combinator: "union";
-    readonly parsers: TParsers;
-    constructor(parsers: TParsers);
-    parse<TInput extends string, $ extends Context>(input: TInput, $: $): ParseUnion<TParsers, TInput, $>;
-}
-declare class _Tuple<TParsers extends IParser[]> {
-    readonly __combinator: "tuple";
-    readonly parsers: TParsers;
-    constructor(parsers: TParsers);
-    parse<TInput extends string, $ extends Context>(input: TInput, $: $): ParseTuple<TParsers, TInput, $>;
-}
-declare class _Optional<TParser extends IParser> {
-    readonly __combinator: "optional";
-    readonly parser: TParser;
-    constructor(parser: TParser);
-    parse<TInput extends string, $ extends Context>(input: TInput, $: $): ParseOptional<TParser, TInput, $>;
-}
-declare class _Many<TParser extends IParser> {
-    readonly __combinator: "many";
-    readonly parser: TParser;
-    constructor(parser: TParser);
-    parse<TInput extends string, $ extends Context>(input: TInput, $: $): ParseMany<TParser, TInput, $>;
-}
-export declare const Union: <TParsers extends IParser[]>(parsers: [...TParsers]) => _Union<TParsers>;
-export declare const Tuple: <TParsers extends IParser[]>(parsers: [...TParsers]) => _Tuple<TParsers>;
-export declare const Optional: <TParser extends IParser>(parser: TParser) => _Optional<TParser>;
-export declare const Many: <TParser extends IParser>(parser: TParser) => _Many<TParser>;
-export type { _Union, _Tuple, _Optional, _Many };

package/dist/combinators/index.js

@@ -1,104 +0,0 @@
-/**
- * Parser Combinators
- *
- * Composable parsers that work at both runtime and compile-time.
- * Parse methods are generic - return types computed from input literals.
- * All combinators thread context ($) through to child parsers.
- *
- * IMPORTANT: All parse methods MUST be generic in context:
- *   parse<TInput extends string, $ extends Context>(input: TInput, $: $)
- */
-// =============================================================================
-// Union Combinator
-// =============================================================================
-class _Union {
-    __combinator = "union";
-    parsers;
-    constructor(parsers) {
-        this.parsers = parsers;
-    }
-    parse(input, $) {
-        for (const parser of this.parsers) {
-            const result = parser.parse(input, $);
-            if (result.length === 2) {
-                return result;
-            }
-        }
-        return [];
-    }
-}
-// =============================================================================
-// Tuple Combinator
-// =============================================================================
-class _Tuple {
-    __combinator = "tuple";
-    parsers;
-    constructor(parsers) {
-        this.parsers = parsers;
-    }
-    parse(input, $) {
-        const results = [];
-        let remaining = input;
-        for (const parser of this.parsers) {
-            const result = parser.parse(remaining, $);
-            if (result.length !== 2) {
-                return [];
-            }
-            results.push(result[0]);
-            remaining = result[1];
-        }
-        return [results, remaining];
-    }
-}
-// =============================================================================
-// Optional Combinator
-// =============================================================================
-class _Optional {
-    __combinator = "optional";
-    parser;
-    constructor(parser) {
-        this.parser = parser;
-    }
-    parse(input, $) {
-        const result = this.parser.parse(input, $);
-        if (result.length === 2) {
-            return result;
-        }
-        return [undefined, input];
-    }
-}
-// =============================================================================
-// Many Combinator
-// =============================================================================
-class _Many {
-    __combinator = "many";
-    parser;
-    constructor(parser) {
-        this.parser = parser;
-    }
-    parse(input, $) {
-        const results = [];
-        let remaining = input;
-        while (true) {
-            const result = this.parser.parse(remaining, $);
-            if (result.length !== 2) {
-                break;
-            }
-            results.push(result[0]);
-            const newRemaining = result[1];
-            // Prevent infinite loop on zero-width matches
-            if (newRemaining === remaining) {
-                break;
-            }
-            remaining = newRemaining;
-        }
-        return [results, remaining];
-    }
-}
-// =============================================================================
-// Exported Factories
-// =============================================================================
-export const Union = (parsers) => new _Union(parsers);
-export const Tuple = (parsers) => new _Tuple(parsers);
-export const Optional = (parser) => new _Optional(parser);
-export const Many = (parser) => new _Many(parser);

package/dist/static/parser.d.ts

@@ -1,7 +0,0 @@
-/**
- * Static Parser Types
- *
- * Parse<Parser, Input, $> - type-level parsing with context threading
- */
-export { Parse, ParseUnion, ParseTuple, ParseOptional, ParseMany, } from "../combinators/index.js";
-export type { LiteralNode, NumberNode, StringNode, IdentNode, ConstNode, ASTNode, } from "../primitive/index.js";

package/dist/static/parser.js

@@ -1,6 +0,0 @@
-/**
- * Static Parser Types
- *
- * Parse<Parser, Input, $> - type-level parsing with context threading
- */
-export {};