@cornjs/parser 0.11.0 → 0.11.1

package/README.md

@@ -1,19 +1,21 @@
-# Corn.JS
-
-Native Typescript implementation of the Corn parser.
-
-This is compliant with the (currently unfinished) v0.11 spec.
-
->![NOTE]
-> Not yet published to NPM.
-
-Usage:
-
-```ts
-import { parse } from '<TBD>';
-
-const corn = "{ let $foo = 42 } in { value = $foo }";
-const res = parse(corn);
-
-if(res.ok) console.log(res.value); // { value: 42 }
-```
+# Corn.JS
+
+Native Typescript implementation of the Corn parser.
+
+This is compliant with the (currently unfinished) v0.11 spec.
+
+## Installation
+
+Add the `@cornjs/parser` package.
+
+## Usage
+
+```ts
+import { parse } from '@cornjs/parser';
+
+const corn = "{ let $foo = 42 } in { value = $foo }";
+const res = parse(corn);
+
+if(res.ok) console.log(res.value); // { value: 42 }
+```
+

package/dist/evaluator.d.ts

@@ -0,0 +1,17 @@
+import { RuleConfig } from "./parser";
+import { Result } from "./utils";
+export type Value = boolean | number | string | null | Value[] | {
+    [k: string]: Value;
+};
+export declare class Evaluator {
+    private inputs;
+    evaluate(rule: RuleConfig): Result<Record<string, Value>, string>;
+    private evaluateAssignBlock;
+    private evaluateObject;
+    private addAtPath;
+    private evaluateArray;
+    private evaluateString;
+    private trimMultilineString;
+    private evaluateValue;
+    private evaluateInput;
+}

package/dist/evaluator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { LexerError } from "./lexer";
+import { Value } from "./evaluator";
+import { Result } from "./utils";
+export type { LexerError } from "./lexer";
+export type { Value } from "./evaluator";
+export type { Result } from "./utils";
+/**
+ * Parses the provided corn string
+ * into an object.
+ *
+ * @typeParam T output object type
+ * @param corn input string
+ * @returns result containing output object on success,
+ * or error variant on any failure.
+ */
+export declare function parse<T extends Record<string, Value> = Record<string, Value>>(corn: string): Result<T, string | LexerError>;

package/dist/lexer.d.ts

@@ -0,0 +1,77 @@
+import { Result } from "./utils";
+type LiteralChar = "{" | "}" | "[" | "]" | "=" | '"' | ".";
+type LiteralString = ".." | "let" | "in" | "true" | "false" | "null";
+export type Token = {
+    type: LiteralChar;
+} | {
+    type: LiteralString;
+} | {
+    type: "pathSegment";
+    value: string;
+} | {
+    type: "integer";
+    value: number;
+} | {
+    type: "float";
+    value: number;
+} | {
+    type: "input";
+    value: string;
+} | {
+    type: "charSequence";
+    value: string;
+} | {
+    type: "charEscape";
+    value: string;
+} | {
+    type: "unicodeEscape";
+    value: number;
+} | {
+    type: "null";
+};
+export type LexerError = {
+    message: string;
+    span: Span;
+};
+export type TokenWithSpan = {
+    token: Token;
+    span: Span;
+};
+export type Span = {
+    startRow: number;
+    endRow: number;
+    startCol: number;
+    endCol: number;
+};
+export declare class Lexer {
+    private row;
+    private col;
+    private readonly MATCHERS;
+    tokenizeInput(inputString: string): Result<TokenWithSpan[], LexerError>;
+    private matchPathSegment;
+    private matchQuotedPathSegment;
+    private matchInteger;
+    private matchFloat;
+    private matchInterpolatedInput;
+    private matchCharEscape;
+    private matchUnicodeEscape;
+    private matchCharSequence;
+    private matchInput;
+    /**
+     * Returns a matcher function for a literal token.
+  
+     * @param str Literal token value.
+     * @private
+     */
+    private matchLiteral;
+    /**
+     * Applies a relative span to the current row/col
+     * to get an absolute span.
+     *
+     * @param relativeSpan
+     * @private
+     */
+    private getAbsoluteSpan;
+    private setSpan;
+}
+export {};

package/dist/parser.d.ts

@@ -0,0 +1,85 @@
+import { Token } from "./lexer";
+import { Result } from "./utils";
+export type RuleConfig = {
+    type: "config";
+    assignBlock?: RuleAssignBlock;
+    object: RuleObject;
+};
+export type RuleAssignBlock = {
+    type: "assignBlock";
+    assignments: RuleAssignment[];
+};
+export type RuleAssignment = {
+    type: "assignment";
+    key: string;
+    value: RuleValue;
+};
+export type RuleInput = {
+    type: "input";
+    value: string;
+};
+export type RuleBoolean = {
+    type: "boolean";
+    value: boolean;
+};
+export type RuleInteger = {
+    type: "integer";
+    value: number;
+};
+export type RuleFloat = {
+    type: "float";
+    value: number;
+};
+export type RuleString = {
+    type: "string";
+    value: RuleStringPart[];
+};
+export type RuleNull = {
+    type: "null";
+};
+export type RuleArray = {
+    type: "array";
+    values: RuleArrayItem[];
+};
+export type RuleObject = {
+    type: "object";
+    pairs: RuleObjectItem[];
+};
+export type RulePair = {
+    type: "pair";
+    path: RulePath;
+    value: RuleValue;
+};
+export type RulePath = {
+    type: "path";
+    value: string[];
+};
+export type RuleSpread = {
+    type: "spread";
+    value: string;
+};
+export type RuleCharSequence = {
+    type: "charSequence";
+    value: string;
+};
+export type RuleCharEscape = {
+    type: "charEscape";
+    value: string;
+};
+export type RuleUnicodeEscape = {
+    type: "unicodeEscape";
+    value: number;
+};
+export type RuleValue = RuleInput | RuleBoolean | RuleInteger | RuleFloat | RuleString | RuleArray | RuleObject | RuleNull;
+export type RuleObjectItem = RulePair | RuleSpread;
+export type RuleArrayItem = RuleValue | RuleSpread;
+export type RuleStringPart = RuleCharSequence | RuleCharEscape | RuleUnicodeEscape | RuleInput;
+/**
+ * Attempts to parse the provided token array
+ * into an AST of rules.
+ *
+ * @param tokens The token array.
+ * @returns A result containing the AST if successfully parsed,
+ * or an error message if not.
+ */
+export declare function parseTokens(tokens: Token[]): Result<RuleConfig, string>;

package/dist/utils.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Represents the outcome of a fallible operation,
+ * where the outcome can be either success value `T` or error `E`.
+ */
+export type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+/**
+ * Creates an ok (success) variant of `Result`.
+ * @param value
+ */
+export declare function ok<T, E>(value: T): Result<T, E>;
+/**
+ * Creates an error variant of `Result`.
+ * @param error
+ */
+export declare function err<T, E>(error: E): Result<T, E>;
+/**
+ * Throws an "unreachable" error if it ever runs.
+ *
+ * This is used as an exhaustive typeguard check on switch blocks,
+ * causing the type checker to error if a non-never type is passed in.
+ * @param _
+ */
+export declare function assertNever(_: never): never;
+/**
+ * Determines if the given character is a numeric digit (0-9).
+ *
+ * @param {string} char - A single character to evaluate.
+ * @return {boolean} True if the character is a digit, otherwise false.
+ */
+export declare function isDigit(char: string): boolean;
+/**
+ * Determines if the given character is a hex digit (0-F), case-insensitive.
+ *
+ * @param {string} char - A single character to evaluate.
+ * @return {boolean} True if the character is a digit, otherwise false.
+ */
+export declare function isHexDigit(char: string): boolean;
+/**
+ * Determines if a given character is a letter (uppercase or lowercase) `[a-zA-Z]`.
+ *
+ * @param {string} char - The character to be checked.
+ * @return {boolean} Returns true if the character is a letter, otherwise false.
+ */
+export declare function isLetter(char: string): boolean;
+export declare function isAlphanumeric(char: string): boolean;
+export declare function isObject(val: unknown): val is Record<string | number | symbol, unknown>;

package/package.json

@@ -8,7 +8,7 @@
   "files": [
     "dist"
   ],
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": " Native Typescript Corn parser",
   "homepage": "https://cornlang.dev",
   "license": "MIT",
@@ -19,14 +19,13 @@
   "bugs": {
     "url": "https://github.com/jakestanger/corn/issues"
   },
-  "keywords": [
-    "corn",
-    "config",
-    "parser",
-    "language",
-    "typescript"
-  ],
+  "keywords": ["corn", "config", "parser", "language", "typescript"],
   "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src",
+    "test": "jest"
+  },
   "dependencies": {
     "dedent": "^1.6.0"
   },
@@ -48,10 +47,5 @@
   },
   "volta": {
     "node": "22.17.1"
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "ts-node src",
-    "test": "jest"
   }
-}
+}