openalgo-script 0.1.0-alpha.0

package/dist/core/tokens/kind.js

@@ -0,0 +1,94 @@
+/**
+ * Every kind of token language.md section 3 describes. Types and the two tables
+ * they are derived from, and no scanning: the lexer is the next stage.
+ *
+ * A keyword's kind is the word, and a punctuation token's kind is the symbol,
+ * so a parser reads as `token.kind === 'if'` and `token.kind === '('` rather
+ * than through a second vocabulary that has to be learned and kept in step.
+ */
+/**
+ * The reserved words of language.md 3.4, which cannot be used as names.
+ *
+ * `import`, `map`, `matrix`, `type` and `as` are reserved and unused in version
+ * 1. They are here so that adding them later cannot break a script that used
+ * one as a variable name.
+ *
+ * Two words the grammar treats as keywords are deliberately absent, because 3.4
+ * does not reserve them: `version` and `limits` are recognised by position in
+ * the parser and are ordinary identifiers to the lexer.
+ */
+export const RESERVED_WORDS = [
+    'and',
+    'array',
+    'as',
+    'bool',
+    'break',
+    'case',
+    'color',
+    'continue',
+    'default',
+    'else',
+    'false',
+    'fn',
+    'for',
+    'if',
+    'import',
+    'in',
+    'is',
+    'live',
+    'map',
+    'matrix',
+    'none',
+    'not',
+    'number',
+    'or',
+    'return',
+    'series',
+    'step',
+    'string',
+    'strategy',
+    'study',
+    'switch',
+    'to',
+    'true',
+    'type',
+    'var',
+    'while',
+];
+/**
+ * The operator and punctuation tokens of language.md 3.12, longest first so a
+ * lexer taking them in order takes the longest match.
+ *
+ * `!` is not in the list and is not an operator on its own: it exists only as
+ * the first half of `!=`, and a lone one is OS1001 with the fix to write `not`.
+ * There are no bitwise, increment or exponent operators for the same reason
+ * they are missing from the specification, so there is nothing here to add.
+ */
+export const PUNCTUATORS = [
+    '==',
+    '!=',
+    '<=',
+    '>=',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '%=',
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '<',
+    '>',
+    '=',
+    '(',
+    ')',
+    '[',
+    ']',
+    ',',
+    '.',
+    '?',
+    ':',
+];
+//# sourceMappingURL=kind.js.map

package/dist/core/tokens/kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind.js","sourceRoot":"","sources":["../../../src/core/tokens/kind.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,KAAK;IACL,OAAO;IACP,IAAI;IACJ,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;IACP,UAAU;IACV,SAAS;IACT,MAAM;IACN,OAAO;IACP,IAAI;IACJ,KAAK;IACL,IAAI;IACJ,QAAQ;IACR,IAAI;IACJ,IAAI;IACJ,MAAM;IACN,KAAK;IACL,QAAQ;IACR,MAAM;IACN,KAAK;IACL,QAAQ;IACR,IAAI;IACJ,QAAQ;IACR,QAAQ;IACR,MAAM;IACN,QAAQ;IACR,UAAU;IACV,OAAO;IACP,QAAQ;IACR,IAAI;IACJ,MAAM;IACN,MAAM;IACN,KAAK;IACL,OAAO;CACC,CAAC;AAIX;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;IACH,GAAG;CACK,CAAC"}

package/dist/core/tokens/token.d.ts

@@ -0,0 +1,36 @@
+import type { Span } from '../span/index.js';
+import type { TokenKind } from './kind.js';
+interface TokenFields {
+    readonly kind: TokenKind;
+    readonly span: Span;
+    /**
+     * The source text the token was read from, exactly as written.
+     *
+     * An indent token's text is the leading spaces of the line it opens, which is
+     * what OS1003 counts when it says how deeply a line was indented. A dedent, a
+     * newline and the end of the file carry no text.
+     */
+    readonly text: string;
+}
+/**
+ * A number literal and the value it denotes.
+ *
+ * The value is carried rather than re-read later because the literal forms of
+ * 3.5 include digit group underscores and a hexadecimal form, and a second
+ * reader of the text would be a second place that has to agree about them.
+ */
+export interface NumberToken extends TokenFields {
+    readonly kind: 'numberLiteral';
+    readonly value: number;
+}
+/** A string literal with its escape sequences already resolved. */
+export interface StringToken extends TokenFields {
+    readonly kind: 'stringLiteral';
+    readonly value: string;
+}
+export interface SimpleToken extends TokenFields {
+    readonly kind: Exclude<TokenKind, 'numberLiteral' | 'stringLiteral'>;
+}
+export type Token = NumberToken | StringToken | SimpleToken;
+export {};
+//# sourceMappingURL=token.d.ts.map

package/dist/core/tokens/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../../src/core/tokens/token.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,UAAU,WAAW;IACnB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,mEAAmE;AACnE,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,WAAY,SAAQ,WAAW;IAC9C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,SAAS,EAAE,eAAe,GAAG,eAAe,CAAC,CAAC;CACtE;AAED,MAAM,MAAM,KAAK,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC"}

package/dist/core/tokens/token.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=token.js.map

package/dist/core/tokens/token.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.js","sourceRoot":"","sources":["../../../src/core/tokens/token.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "openalgo-script",
+  "version": "0.1.0-alpha.0",
+  "description": "An open trading language. Write a study or a strategy once, plot it, backtest it, trade it.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "spec/errors.json",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ],
+  "scripts": {
+    "check:names": "node scripts/check-names.mjs",
+    "check:examples": "node scripts/check-examples.mjs",
+    "check:errors": "node scripts/check-error-codes.mjs",
+    "test": "node scripts/check-duplication.mjs && node scripts/check-error-codes.mjs && node scripts/check-examples.mjs && node scripts/check-layering.mjs && node scripts/check-modularity.mjs && node scripts/check-names.mjs && npm run build && npm run test:unit",
+    "test:unit": "npm run generate:errors && tsc -p tsconfig.test.json && node --test \"dist-test/tests/**/*.test.js\"",
+    "check:layering": "node scripts/check-layering.mjs",
+    "check:duplication": "node scripts/check-duplication.mjs",
+    "check:modularity": "node scripts/check-modularity.mjs",
+    "generate:errors": "node scripts/generate-error-catalogue.mjs",
+    "typecheck": "npm run generate:errors && tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
+    "build": "npm run generate:errors && tsc -p tsconfig.json",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "trading",
+    "language",
+    "compiler",
+    "indicators",
+    "backtesting",
+    "technical-analysis"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0"
+  }
+}

package/spec/README.md

@@ -0,0 +1,48 @@
+# Specification
+
+These are the documents that make up the specification. All of them are being
+written now, and the implementation follows them rather than the other way
+round.
+
+| Document | Holds |
+|---|---|
+| [`language.md`](./language.md) | Syntax, types, scope, the per-bar execution model, the shape of the library |
+| [`stdlib.md`](./stdlib.md) | The library catalogue: every name a script can call, its signature, its warmup, where it lands in the chart contract |
+| [`compiled-program.md`](./compiled-program.md) | The versioned schema and machine every engine reads. The contract that lets a second implementation exist |
+| [`errors.md`](./errors.md) | The error catalogue: code, cause, fix, example, for every error a compiler or an engine can emit |
+| [`host-interface.md`](./host-interface.md) | Everything a platform supplies so an engine can run, and everything the engine hands back: the boundary |
+| [`conformance.md`](./conformance.md) | How the suite is run, and what a passing result entitles an implementation to claim |
+
+Six documents, and the list above is the whole of it. Two more files sit beside
+them and are not the specification:
+
+| File | Holds |
+|---|---|
+| [`decisions.md`](./decisions.md) | The minutes of every settled cross-document question, and the home register that says which document owns each fact |
+| [`feature-matrix.md`](./feature-matrix.md) | One row per feature: whether it is specified, implemented or planned, the section that defines it, and the test that proves it |
+
+`errors.json` is `errors.md` in machine form, generated from the same entries.
+It is not a document of its own, and a change to one is the same change to the
+other.
+
+## Which document wins
+
+Two documents that disagree are a defect, and until it is fixed a reader still
+needs an answer. These are the answers.
+
+| The disagreement is about | The document that wins |
+|---|---|
+| The text of a code: its message, its cause, its fix | `errors.md` |
+| A rule of the language | `language.md` |
+| A function: its arguments, its result, its warmup | `stdlib.md` |
+| A representation: a field name, a wire value, an encoding | `compiled-program.md` |
+| The boundary: what a host supplies and what it is handed | `host-interface.md` |
+| The suite: a case, a runner, a profile, a claim | `conformance.md` |
+
+Where none of those settles it, the home register in `decisions.md` names the
+document that owns the fact, and every other document cites that one rather than
+restating it.
+
+Values: `"alpha"`, `"beta"`, `"gamma"`.
+
+One of `"alpha"`, `"beta"`, `"gamma"`.