gradient-script 0.1.0

package/dist/dsl/Lexer.js

@@ -0,0 +1,243 @@
+/**
+ * Lexer for GradientScript DSL
+ * Tokenizes input with support for ∇, ^, **, and structured types
+ */
+export var TokenType;
+(function (TokenType) {
+    // Literals
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    // Keywords
+    TokenType["FUNCTION"] = "FUNCTION";
+    TokenType["RETURN"] = "RETURN";
+    // Operators
+    TokenType["PLUS"] = "PLUS";
+    TokenType["MINUS"] = "MINUS";
+    TokenType["MULTIPLY"] = "MULTIPLY";
+    TokenType["DIVIDE"] = "DIVIDE";
+    TokenType["POWER"] = "POWER";
+    TokenType["POWER_ALT"] = "POWER_ALT";
+    TokenType["NABLA"] = "NABLA";
+    // Delimiters
+    TokenType["LPAREN"] = "LPAREN";
+    TokenType["RPAREN"] = "RPAREN";
+    TokenType["LBRACE"] = "LBRACE";
+    TokenType["RBRACE"] = "RBRACE";
+    TokenType["COMMA"] = "COMMA";
+    TokenType["COLON"] = "COLON";
+    TokenType["DOT"] = "DOT";
+    TokenType["EQUALS"] = "EQUALS";
+    // Special
+    TokenType["NEWLINE"] = "NEWLINE";
+    TokenType["EOF"] = "EOF";
+})(TokenType || (TokenType = {}));
+export class Lexer {
+    input;
+    position = 0;
+    line = 1;
+    column = 1;
+    constructor(input) {
+        this.input = input;
+    }
+    /**
+     * Get all tokens
+     */
+    tokenize() {
+        const tokens = [];
+        let token = this.nextToken();
+        while (token.type !== TokenType.EOF) {
+            if (token.type !== TokenType.NEWLINE) {
+                // Skip newlines for now (treat as whitespace)
+                tokens.push(token);
+            }
+            token = this.nextToken();
+        }
+        tokens.push(token); // EOF token
+        return tokens;
+    }
+    /**
+     * Get next token
+     */
+    nextToken() {
+        this.skipWhitespace();
+        if (this.isAtEnd()) {
+            return this.makeToken(TokenType.EOF, '');
+        }
+        const char = this.peek();
+        const line = this.line;
+        const column = this.column;
+        // Numbers
+        if (this.isDigit(char)) {
+            return this.number();
+        }
+        // Identifiers and keywords
+        if (this.isAlpha(char)) {
+            return this.identifier();
+        }
+        // Single character tokens
+        switch (char) {
+            case '+':
+                this.advance();
+                return { type: TokenType.PLUS, value: '+', line, column };
+            case '-':
+                this.advance();
+                return { type: TokenType.MINUS, value: '-', line, column };
+            case '/':
+                this.advance();
+                return { type: TokenType.DIVIDE, value: '/', line, column };
+            case '(':
+                this.advance();
+                return { type: TokenType.LPAREN, value: '(', line, column };
+            case ')':
+                this.advance();
+                return { type: TokenType.RPAREN, value: ')', line, column };
+            case '{':
+                this.advance();
+                return { type: TokenType.LBRACE, value: '{', line, column };
+            case '}':
+                this.advance();
+                return { type: TokenType.RBRACE, value: '}', line, column };
+            case ',':
+                this.advance();
+                return { type: TokenType.COMMA, value: ',', line, column };
+            case ':':
+                this.advance();
+                return { type: TokenType.COLON, value: ':', line, column };
+            case '.':
+                this.advance();
+                return { type: TokenType.DOT, value: '.', line, column };
+            case '=':
+                this.advance();
+                return { type: TokenType.EQUALS, value: '=', line, column };
+            case '^':
+                this.advance();
+                return { type: TokenType.POWER, value: '^', line, column };
+            case '∇':
+                this.advance();
+                return { type: TokenType.NABLA, value: '∇', line, column };
+            case '*':
+                this.advance();
+                if (this.peek() === '*') {
+                    this.advance();
+                    return { type: TokenType.POWER_ALT, value: '**', line, column };
+                }
+                return { type: TokenType.MULTIPLY, value: '*', line, column };
+            case '\n':
+                this.advance();
+                return { type: TokenType.NEWLINE, value: '\n', line, column };
+        }
+        throw new Error(`Unexpected character '${char}' at line ${line}, column ${column}`);
+    }
+    number() {
+        const line = this.line;
+        const column = this.column;
+        let value = '';
+        while (this.isDigit(this.peek())) {
+            value += this.advance();
+        }
+        // Handle decimal point
+        if (this.peek() === '.' && this.isDigit(this.peekNext())) {
+            value += this.advance(); // consume '.'
+            while (this.isDigit(this.peek())) {
+                value += this.advance();
+            }
+        }
+        // Handle scientific notation
+        if (this.peek() === 'e' || this.peek() === 'E') {
+            value += this.advance(); // consume 'e'
+            if (this.peek() === '+' || this.peek() === '-') {
+                value += this.advance();
+            }
+            while (this.isDigit(this.peek())) {
+                value += this.advance();
+            }
+        }
+        return { type: TokenType.NUMBER, value, line, column };
+    }
+    identifier() {
+        const line = this.line;
+        const column = this.column;
+        let value = '';
+        while (this.isAlphaNumeric(this.peek())) {
+            value += this.advance();
+        }
+        // Check for keywords
+        let type = TokenType.IDENTIFIER;
+        if (value === 'function') {
+            type = TokenType.FUNCTION;
+        }
+        else if (value === 'return') {
+            type = TokenType.RETURN;
+        }
+        return { type, value, line, column };
+    }
+    skipWhitespace() {
+        while (!this.isAtEnd()) {
+            const char = this.peek();
+            if (char === ' ' || char === '\r' || char === '\t') {
+                this.advance();
+            }
+            else if (char === '/' && this.peekNext() === '/') {
+                // Skip single-line comment
+                while (this.peek() !== '\n' && !this.isAtEnd()) {
+                    this.advance();
+                }
+            }
+            else if (char === '\n') {
+                // Don't skip newlines here - they're tokens
+                break;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    peek() {
+        if (this.isAtEnd())
+            return '\0';
+        return this.input[this.position];
+    }
+    peekNext() {
+        if (this.position + 1 >= this.input.length)
+            return '\0';
+        return this.input[this.position + 1];
+    }
+    advance() {
+        const char = this.input[this.position++];
+        if (char === '\n') {
+            this.line++;
+            this.column = 1;
+        }
+        else {
+            this.column++;
+        }
+        return char;
+    }
+    isAtEnd() {
+        return this.position >= this.input.length;
+    }
+    isDigit(char) {
+        return char >= '0' && char <= '9';
+    }
+    isAlpha(char) {
+        return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || char === '_';
+    }
+    isAlphaNumeric(char) {
+        return this.isAlpha(char) || this.isDigit(char);
+    }
+    makeToken(type, value) {
+        return {
+            type,
+            value,
+            line: this.line,
+            column: this.column
+        };
+    }
+}
+/**
+ * Convenience function to tokenize input
+ */
+export function tokenize(input) {
+    const lexer = new Lexer(input);
+    return lexer.tokenize();
+}

package/dist/dsl/Parser.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Parser for GradientScript DSL
+ * Parses function definitions with structured types
+ */
+import { Program } from './AST.js';
+export declare class Parser {
+    private tokens;
+    private current;
+    constructor(input: string);
+    /**
+     * Parse the entire program
+     */
+    parse(): Program;
+    /**
+     * Parse function definition
+     * function name(param1∇: {x, y}, param2) { ... }
+     */
+    private functionDef;
+    /**
+     * Parse parameter list
+     * param1∇: {x, y}, param2, param3∇
+     */
+    private parameterList;
+    /**
+     * Parse single parameter
+     * name∇: {x, y} or name or name∇
+     */
+    private parameter;
+    /**
+     * Parse struct type annotation
+     * {x, y} or {x, y, z}
+     */
+    private structTypeAnnotation;
+    /**
+     * Parse function body
+     * sequence of assignments followed by return
+     */
+    private functionBody;
+    /**
+     * Parse statement (currently only assignment)
+     */
+    private statement;
+    /**
+     * Parse assignment
+     * variable = expression
+     */
+    private assignment;
+    /**
+     * Parse expression
+     */
+    private expression;
+    /**
+     * Parse additive expression (+ and -)
+     */
+    private additive;
+    /**
+     * Parse multiplicative expression (* and /)
+     */
+    private multiplicative;
+    /**
+     * Parse power expression (^ and **)
+     */
+    private power;
+    /**
+     * Parse unary expression (- and +)
+     */
+    private unary;
+    /**
+     * Parse postfix expression (function calls and component access)
+     */
+    private postfix;
+    /**
+     * Parse argument list for function call
+     */
+    private argumentList;
+    /**
+     * Parse primary expression
+     */
+    private primary;
+    private match;
+    private check;
+    private advance;
+    private isAtEnd;
+    private peek;
+    private previous;
+    private consume;
+    private error;
+}
+/**
+ * Convenience function to parse input
+ */
+export declare function parse(input: string): Program;

package/dist/dsl/Parser.js

@@ -0,0 +1,328 @@
+/**
+ * Parser for GradientScript DSL
+ * Parses function definitions with structured types
+ */
+import { TokenType, Lexer } from './Lexer.js';
+import { ParseError } from './Errors.js';
+export class Parser {
+    tokens;
+    current = 0;
+    constructor(input) {
+        const lexer = new Lexer(input);
+        this.tokens = lexer.tokenize();
+    }
+    /**
+     * Parse the entire program
+     */
+    parse() {
+        const functions = [];
+        while (!this.isAtEnd()) {
+            functions.push(this.functionDef());
+        }
+        if (functions.length === 0) {
+            const token = this.peek();
+            throw new ParseError('Expected at least one function definition', token.line, token.column);
+        }
+        return {
+            kind: 'program',
+            functions
+        };
+    }
+    /**
+     * Parse function definition
+     * function name(param1∇: {x, y}, param2) { ... }
+     */
+    functionDef() {
+        this.consume(TokenType.FUNCTION, "Expected 'function'");
+        const name = this.consume(TokenType.IDENTIFIER, 'Expected function name').value;
+        this.consume(TokenType.LPAREN, "Expected '(' after function name");
+        const parameters = this.parameterList();
+        this.consume(TokenType.RPAREN, "Expected ')' after parameters");
+        this.consume(TokenType.LBRACE, "Expected '{' before function body");
+        const { body, returnExpr } = this.functionBody();
+        this.consume(TokenType.RBRACE, "Expected '}' after function body");
+        return {
+            kind: 'function',
+            name,
+            parameters,
+            body,
+            returnExpr
+        };
+    }
+    /**
+     * Parse parameter list
+     * param1∇: {x, y}, param2, param3∇
+     */
+    parameterList() {
+        const params = [];
+        if (this.check(TokenType.RPAREN)) {
+            return params; // Empty parameter list
+        }
+        do {
+            params.push(this.parameter());
+        } while (this.match(TokenType.COMMA));
+        return params;
+    }
+    /**
+     * Parse single parameter
+     * name∇: {x, y} or name or name∇
+     */
+    parameter() {
+        const nameToken = this.consume(TokenType.IDENTIFIER, 'Expected parameter name');
+        const name = nameToken.value;
+        // Check for ∇ (gradient annotation)
+        const requiresGrad = this.match(TokenType.NABLA);
+        // Check for type annotation : {x, y}
+        let paramType;
+        if (this.match(TokenType.COLON)) {
+            paramType = this.structTypeAnnotation();
+        }
+        return {
+            name,
+            requiresGrad,
+            paramType
+        };
+    }
+    /**
+     * Parse struct type annotation
+     * {x, y} or {x, y, z}
+     */
+    structTypeAnnotation() {
+        this.consume(TokenType.LBRACE, "Expected '{'");
+        const components = [];
+        do {
+            const comp = this.consume(TokenType.IDENTIFIER, 'Expected component name');
+            components.push(comp.value);
+        } while (this.match(TokenType.COMMA));
+        this.consume(TokenType.RBRACE, "Expected '}'");
+        return { components };
+    }
+    /**
+     * Parse function body
+     * sequence of assignments followed by return
+     */
+    functionBody() {
+        const body = [];
+        // Parse statements until we hit return
+        while (!this.check(TokenType.RETURN) && !this.check(TokenType.RBRACE)) {
+            body.push(this.statement());
+        }
+        // Parse return statement
+        this.consume(TokenType.RETURN, "Expected 'return' statement");
+        const returnExpr = this.expression();
+        return { body, returnExpr };
+    }
+    /**
+     * Parse statement (currently only assignment)
+     */
+    statement() {
+        return this.assignment();
+    }
+    /**
+     * Parse assignment
+     * variable = expression
+     */
+    assignment() {
+        const variable = this.consume(TokenType.IDENTIFIER, 'Expected variable name').value;
+        this.consume(TokenType.EQUALS, "Expected '=' in assignment");
+        const expression = this.expression();
+        return {
+            kind: 'assignment',
+            variable,
+            expression
+        };
+    }
+    /**
+     * Parse expression
+     */
+    expression() {
+        return this.additive();
+    }
+    /**
+     * Parse additive expression (+ and -)
+     */
+    additive() {
+        let expr = this.multiplicative();
+        while (this.match(TokenType.PLUS, TokenType.MINUS)) {
+            const operator = this.previous().value;
+            const right = this.multiplicative();
+            expr = {
+                kind: 'binary',
+                operator,
+                left: expr,
+                right
+            };
+        }
+        return expr;
+    }
+    /**
+     * Parse multiplicative expression (* and /)
+     */
+    multiplicative() {
+        let expr = this.power();
+        while (this.match(TokenType.MULTIPLY, TokenType.DIVIDE)) {
+            const operator = this.previous().value;
+            const right = this.power();
+            expr = {
+                kind: 'binary',
+                operator,
+                left: expr,
+                right
+            };
+        }
+        return expr;
+    }
+    /**
+     * Parse power expression (^ and **)
+     */
+    power() {
+        let expr = this.unary();
+        // Right-associative
+        if (this.match(TokenType.POWER, TokenType.POWER_ALT)) {
+            const operator = this.previous().type === TokenType.POWER ? '^' : '**';
+            const right = this.power(); // Right-associative recursion
+            expr = {
+                kind: 'binary',
+                operator,
+                left: expr,
+                right
+            };
+        }
+        return expr;
+    }
+    /**
+     * Parse unary expression (- and +)
+     */
+    unary() {
+        if (this.match(TokenType.MINUS, TokenType.PLUS)) {
+            const operator = this.previous().value;
+            const operand = this.unary();
+            return {
+                kind: 'unary',
+                operator,
+                operand
+            };
+        }
+        return this.postfix();
+    }
+    /**
+     * Parse postfix expression (function calls and component access)
+     */
+    postfix() {
+        let expr = this.primary();
+        while (true) {
+            if (this.match(TokenType.LPAREN)) {
+                // Function call
+                const args = this.argumentList();
+                this.consume(TokenType.RPAREN, "Expected ')' after arguments");
+                if (expr.kind !== 'variable') {
+                    const token = this.previous();
+                    throw new ParseError('Only simple function names are supported', token.line, token.column);
+                }
+                expr = {
+                    kind: 'call',
+                    name: expr.name,
+                    args
+                };
+            }
+            else if (this.match(TokenType.DOT)) {
+                // Component access
+                const component = this.consume(TokenType.IDENTIFIER, 'Expected component name after "."').value;
+                expr = {
+                    kind: 'component',
+                    object: expr,
+                    component
+                };
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    }
+    /**
+     * Parse argument list for function call
+     */
+    argumentList() {
+        const args = [];
+        if (this.check(TokenType.RPAREN)) {
+            return args; // Empty argument list
+        }
+        do {
+            args.push(this.expression());
+        } while (this.match(TokenType.COMMA));
+        return args;
+    }
+    /**
+     * Parse primary expression
+     */
+    primary() {
+        // Number
+        if (this.match(TokenType.NUMBER)) {
+            const value = parseFloat(this.previous().value);
+            return {
+                kind: 'number',
+                value
+            };
+        }
+        // Variable
+        if (this.match(TokenType.IDENTIFIER)) {
+            const name = this.previous().value;
+            return {
+                kind: 'variable',
+                name
+            };
+        }
+        // Parenthesized expression
+        if (this.match(TokenType.LPAREN)) {
+            const expr = this.expression();
+            this.consume(TokenType.RPAREN, "Expected ')' after expression");
+            return expr;
+        }
+        throw this.error(this.peek(), 'Expected expression');
+    }
+    // Helper methods
+    match(...types) {
+        for (const type of types) {
+            if (this.check(type)) {
+                this.advance();
+                return true;
+            }
+        }
+        return false;
+    }
+    check(type) {
+        if (this.isAtEnd())
+            return false;
+        return this.peek().type === type;
+    }
+    advance() {
+        if (!this.isAtEnd())
+            this.current++;
+        return this.previous();
+    }
+    isAtEnd() {
+        return this.peek().type === TokenType.EOF;
+    }
+    peek() {
+        return this.tokens[this.current];
+    }
+    previous() {
+        return this.tokens[this.current - 1];
+    }
+    consume(type, message) {
+        if (this.check(type))
+            return this.advance();
+        throw this.error(this.peek(), message);
+    }
+    error(token, message) {
+        return new ParseError(message, token.line, token.column, token.value);
+    }
+}
+/**
+ * Convenience function to parse input
+ */
+export function parse(input) {
+    const parser = new Parser(input);
+    return parser.parse();
+}

package/dist/dsl/Simplify.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Expression simplification for GradientScript DSL
+ * Applies algebraic simplification rules
+ */
+import { Expression } from './AST.js';
+/**
+ * Simplify an expression using algebraic rules
+ */
+export declare function simplify(expr: Expression): Expression;
+/**
+ * Simplify all gradients in a map
+ */
+export declare function simplifyGradients(gradients: Map<string, Expression | {
+    components: Map<string, Expression>;
+}>): Map<string, Expression | {
+    components: Map<string, Expression>;
+}>;