hascii 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,489 @@
+import { ZodIssue, z } from "zod";
+
+//#region src/compiler/ansi.d.ts
+declare const ANSI: Readonly<{
+  RESET: "\u001B[0m";
+  BOLD: "\u001B[1m";
+  DIM: "\u001B[2m";
+  RED: "\u001B[31m";
+  GREEN: "\u001B[32m";
+  YELLOW: "\u001B[33m";
+  BLUE: "\u001B[34m";
+  MAGENTA: "\u001B[35m";
+  CYAN: "\u001B[36m";
+  BRIGHT_RED: "\u001B[91m";
+  BRIGHT_BLUE: "\u001B[94m";
+}>;
+declare const COLORS: Readonly<{
+  error: "\u001B[1m\u001B[91m";
+  category: "\u001B[1m\u001B[36m";
+  location: "\u001B[94m";
+  lineNumber: "\u001B[94m";
+  gutter: "\u001B[94m";
+  arrow: "\u001B[91m";
+  hint: "\u001B[33m";
+  help: "\u001B[32m";
+  expected: "\u001B[32m";
+  received: "\u001B[31m";
+  note: "\u001B[36m";
+  emphasis: "\u001B[1m\u001B[35m";
+}>;
+declare const BOX: Readonly<{
+  TOP: "┌";
+  VERT: "│";
+  BOTTOM: "└";
+  HORIZ: "─";
+  CROSS: "┼";
+}>;
+declare function supportsColor(): boolean;
+declare function stripAnsi(text: string): string;
+declare function line(char: string, length: number): string;
+//#endregion
+//#region src/compiler/error-codes.d.ts
+type HasciiErrorCode = {
+  readonly code: string;
+  readonly title: string;
+  readonly hint: string;
+};
+declare const ERROR_CODES: Readonly<{
+  E001: HasciiErrorCode;
+  E101: HasciiErrorCode;
+  E102: HasciiErrorCode;
+  E103: HasciiErrorCode;
+  E104: HasciiErrorCode;
+  E201: HasciiErrorCode;
+  E301: HasciiErrorCode;
+  E302: HasciiErrorCode;
+  E303: HasciiErrorCode;
+  E304: HasciiErrorCode;
+  E305: HasciiErrorCode;
+  E401: HasciiErrorCode;
+}>;
+declare function mapZodCodeToErrorCode(zodCode: string, path: readonly (string | number)[]): HasciiErrorCode;
+//#endregion
+//#region src/core/types.d.ts
+type HasciiValueObject = {
+  readonly [key: string]: HasciiValue;
+};
+type HasciiValue = number | string | boolean | readonly HasciiValue[] | HasciiValueObject;
+type HasciiButtonState = {
+  readonly left: number;
+  readonly right: number;
+  readonly up: number;
+  readonly down: number;
+  readonly a: number;
+  readonly b: number;
+};
+type HasciiProgram = {
+  readonly init: Record<string, HasciiValue>;
+  readonly update: readonly HasciiStatement[];
+  readonly draw: readonly HasciiStatement[];
+};
+type HasciiExpression = number | string | {
+  readonly add: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly sub: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly mul: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly div: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly mod: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly pow: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly abs: HasciiExpression;
+} | {
+  readonly neg: HasciiExpression;
+} | {
+  readonly floor: HasciiExpression;
+} | {
+  readonly ceil: HasciiExpression;
+} | {
+  readonly round: HasciiExpression;
+} | {
+  readonly sqrt: HasciiExpression;
+} | {
+  readonly sin: HasciiExpression;
+} | {
+  readonly cos: HasciiExpression;
+} | {
+  readonly min: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly max: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly rnd: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly eq: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly lt: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly lte: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly gt: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly gte: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly and: readonly HasciiExpression[];
+} | {
+  readonly or: readonly HasciiExpression[];
+} | {
+  readonly not: HasciiExpression;
+} | {
+  readonly at: readonly [HasciiExpression, HasciiExpression];
+} | {
+  readonly len: HasciiExpression;
+};
+type HasciiSetStatement = {
+  readonly set: Record<string, HasciiExpression>;
+};
+type HasciiIfStatement = {
+  readonly if: HasciiExpression;
+  readonly then?: readonly HasciiStatement[];
+  readonly else?: readonly HasciiStatement[];
+  readonly set?: Record<string, HasciiExpression>;
+};
+type HasciiEachStatement = {
+  readonly each: string;
+  readonly as: string;
+  readonly index?: string;
+  readonly do: readonly HasciiStatement[];
+};
+type HasciiPushStatement = {
+  readonly push: {
+    readonly to: string;
+    readonly item: HasciiExpression;
+  };
+};
+type HasciiFilterStatement = {
+  readonly filter: {
+    readonly list: string;
+    readonly as: string;
+    readonly cond: HasciiExpression;
+  };
+};
+type StrokeStyle = "light" | "heavy" | "double" | "round";
+type HasciiFillStatement = {
+  readonly fill: HasciiExpression;
+};
+type HasciiStrokeStatement = {
+  readonly stroke: HasciiExpression;
+};
+type HasciiNoFillStatement = {
+  readonly noFill?: true;
+};
+type HasciiNoStrokeStatement = {
+  readonly noStroke?: true;
+};
+type HasciiStrokeStyleStatement = {
+  readonly strokeStyle: StrokeStyle;
+};
+type HasciiClsStatement = {
+  readonly cls?: true;
+};
+type HasciiRectStatement = {
+  readonly rect: readonly [HasciiExpression, HasciiExpression, HasciiExpression, HasciiExpression];
+};
+type HasciiPrintStatement = {
+  readonly print: readonly [HasciiExpression, HasciiExpression, HasciiExpression];
+};
+type WaveType = "tri" | "saw" | "sqr" | "pls" | "org" | "noi" | "pha" | "sin";
+type EffectType = "pitchUp" | "vibrato" | "pitchDown" | "fadeIn" | "fadeOut";
+type HasciiSfxStatement = {
+  readonly sfx: {
+    readonly wave: WaveType;
+    readonly freq: HasciiExpression;
+    readonly length: HasciiExpression;
+    readonly volume: HasciiExpression;
+    readonly effect?: EffectType;
+  };
+};
+type HasciiStatement = HasciiSetStatement | HasciiIfStatement | HasciiEachStatement | HasciiPushStatement | HasciiFilterStatement | HasciiFillStatement | HasciiStrokeStatement | HasciiNoFillStatement | HasciiNoStrokeStatement | HasciiStrokeStyleStatement | HasciiClsStatement | HasciiRectStatement | HasciiPrintStatement | HasciiSfxStatement;
+type SfxNote = {
+  readonly pitch: number;
+  readonly waveform: number;
+  readonly volume: number;
+  readonly effect: number;
+};
+type Sfx = {
+  readonly notes: readonly SfxNote[];
+  readonly speed: number;
+  readonly loopStart: number;
+  readonly loopEnd: number;
+};
+type MusicPattern = {
+  readonly ch0: number;
+  readonly ch1: number;
+  readonly ch2: number;
+  readonly ch3: number;
+  readonly flags: number;
+};
+type HasciiMusic = {
+  readonly sfx: readonly Sfx[];
+  readonly patterns: readonly MusicPattern[];
+};
+//#endregion
+//#region src/compiler/evaluate.d.ts
+type HasciiState$2 = Record<string, HasciiValue>;
+declare function evaluate(expr: HasciiExpression, state: HasciiState$2, depth?: number): HasciiValue;
+//#endregion
+//#region src/core/errors.d.ts
+declare class HasciiError extends Error {
+  constructor(message: string);
+}
+declare class HasciiParseError extends HasciiError {
+  readonly source: string;
+  constructor(message: string, source?: string);
+}
+declare class HasciiValidationError extends HasciiError {
+  readonly issues: readonly ZodIssue[];
+  readonly source: string;
+  constructor(message: string, issues?: readonly ZodIssue[], source?: string);
+}
+declare class HasciiRuntimeError extends HasciiError {
+  constructor(message: string);
+}
+//#endregion
+//#region src/compiler/parser.d.ts
+type HasciiCompileError = HasciiParseError | HasciiValidationError;
+declare function compile(source: string): HasciiProgram | HasciiCompileError;
+//#endregion
+//#region src/compiler/formatter.d.ts
+declare function formatError(error: HasciiCompileError): string;
+//#endregion
+//#region src/compiler/source-map/types.d.ts
+type SourceLocation = {
+  readonly line: number;
+  readonly column: number;
+  readonly offset: number;
+  readonly length: number;
+};
+type SourceMapEntry = {
+  readonly path: readonly (string | number)[];
+  readonly location: SourceLocation;
+};
+type SourceMap = {
+  readonly entries: readonly SourceMapEntry[];
+  readonly source: string;
+  readonly lines: readonly string[];
+};
+//#endregion
+//#region src/compiler/source-map/create.d.ts
+declare function createSourceMap(source: string): SourceMap;
+//#endregion
+//#region src/compiler/source-map/query.d.ts
+declare function findLocation(sourceMap: SourceMap, path: readonly (string | number)[]): SourceLocation | null;
+declare function getSourceLine(sourceMap: SourceMap, lineNumber: number): string;
+//#endregion
+//#region src/core/models.d.ts
+declare const hasciiProgramSchema: z.ZodUnion<readonly [z.ZodObject<{
+  meta: z.ZodObject<{
+    title: z.ZodString;
+    frame: z.ZodNumber;
+    bg: z.ZodNumber;
+    art: z.ZodArray<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"tracker">;
+  }, z.core.$strip>;
+  tracker: z.ZodObject<{
+    bpm: z.ZodOptional<z.ZodNumber>;
+    items: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      steps: z.ZodArray<z.ZodArray<z.ZodObject<{
+        pitch: z.ZodNumber;
+        octave: z.ZodOptional<z.ZodNumber>;
+        volume: z.ZodOptional<z.ZodNumber>;
+        effect: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  meta: z.ZodObject<{
+    title: z.ZodString;
+    frame: z.ZodNumber;
+    bg: z.ZodNumber;
+    art: z.ZodArray<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"music">;
+  }, z.core.$strip>;
+  music: z.ZodArray<z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    bpm: z.ZodOptional<z.ZodNumber>;
+    tracks: z.ZodArray<z.ZodObject<{
+      channel: z.ZodOptional<z.ZodNumber>;
+      wave: z.ZodOptional<z.ZodEnum<{
+        tri: "tri";
+        saw: "saw";
+        sqr: "sqr";
+        pls: "pls";
+        org: "org";
+        noi: "noi";
+        pha: "pha";
+        sin: "sin";
+      }>>;
+      notes: z.ZodArray<z.ZodObject<{
+        time: z.ZodNumber;
+        pitch: z.ZodNumber;
+        octave: z.ZodOptional<z.ZodNumber>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        volume: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  meta: z.ZodOptional<z.ZodObject<{
+    title: z.ZodString;
+    frame: z.ZodNumber;
+    bg: z.ZodNumber;
+    art: z.ZodArray<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"game">;
+  }, z.core.$strip>>;
+  init: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>>;
+  update: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>>;
+  draw: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>>;
+}, z.core.$strip>, z.ZodObject<{
+  meta: z.ZodOptional<z.ZodObject<{
+    title: z.ZodString;
+    frame: z.ZodNumber;
+    bg: z.ZodNumber;
+    art: z.ZodArray<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  init: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>>;
+  update: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>>;
+  draw: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>>;
+}, z.core.$strip>]>;
+type HasciiProgramParsed = z.infer<typeof hasciiProgramSchema>;
+//#endregion
+//#region src/core/safe-key.d.ts
+declare function isSafeKey(key: string): boolean;
+declare function isSafePath(path: string): boolean;
+//#endregion
+//#region src/runtime/button-state.d.ts
+type KeyTimestamps = {
+  readonly left: number;
+  readonly right: number;
+  readonly up: number;
+  readonly down: number;
+  readonly a: number;
+  readonly b: number;
+};
+declare function createButtonState(): HasciiButtonState;
+declare function createKeyTimestamps(): KeyTimestamps;
+declare function updateKeyTimestamps(timestamps: KeyTimestamps, btn: HasciiButtonState, now: number): KeyTimestamps;
+declare function getActiveButtons(timestamps: KeyTimestamps, now: number, holdMs: number): HasciiButtonState;
+declare function getPressedButtons(prev: HasciiButtonState, curr: HasciiButtonState): HasciiButtonState;
+declare function isValidKey(key: string): boolean;
+declare function processKeyInput(key: Buffer): HasciiButtonState;
+//#endregion
+//#region src/runtime/interpreter/types.d.ts
+type DrawState = {
+  readonly fill: number | null;
+  readonly stroke: number | null;
+  readonly strokeStyle: StrokeStyle;
+};
+type HasciiDrawCommand = {
+  type: "cls";
+  bg: number;
+} | {
+  type: "rect";
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  fill: number | null;
+  stroke: number | null;
+  strokeStyle: StrokeStyle;
+} | {
+  type: "print";
+  text: string;
+  x: number;
+  y: number;
+  fg: number;
+  bg: number | null;
+} | {
+  type: "sfx";
+  wave: WaveType;
+  freq: number;
+  length: number;
+  volume: number;
+  effect: EffectType | null;
+};
+type HasciiState = Record<string, HasciiValue>;
+type ExecuteResult = {
+  readonly state: HasciiState;
+  readonly commands: readonly HasciiDrawCommand[];
+  readonly drawState: DrawState;
+};
+//#endregion
+//#region src/runtime/game.d.ts
+type GameInstance = {
+  readonly program: HasciiProgram;
+  readonly gameState: Record<string, HasciiValue>;
+  readonly btn: HasciiButtonState;
+  readonly prevBtn: HasciiButtonState;
+};
+type TickResult = {
+  readonly game: GameInstance;
+  readonly commands: readonly HasciiDrawCommand[];
+};
+/**
+ * Create a new game instance from a program
+ */
+declare function createGame(program: HasciiProgram): GameInstance;
+/**
+ * Tick the game: update state and generate draw commands
+ * This is a pure function - no side effects
+ */
+declare function tick(game: GameInstance, btn: HasciiButtonState): TickResult;
+//#endregion
+//#region src/runtime/interpreter/execute.d.ts
+declare function createDrawState(): DrawState;
+declare function executeStatements(statements: readonly HasciiStatement[], state: HasciiState, drawState?: DrawState): ExecuteResult;
+//#endregion
+//#region src/runtime/raw-mode.d.ts
+declare function enableRawMode(): void;
+declare function disableRawMode(): void;
+//#endregion
+//#region src/runtime/render/index.d.ts
+declare function render(commands: readonly HasciiDrawCommand[], canvasWidth: number, canvasHeight: number): void;
+//#endregion
+//#region src/runtime/render/canvas.d.ts
+type CanvasRegion = {
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+};
+/**
+ * Render draw commands to an ANSI string.
+ * Pure function - no side effects.
+ *
+ * @param commands - Draw commands from game tick
+ * @param region - Where to render the canvas (screen coordinates)
+ * @returns ANSI escape sequence string
+ */
+declare function renderCanvas(commands: readonly HasciiDrawCommand[], region: CanvasRegion): string;
+//#endregion
+//#region src/runtime/run.d.ts
+type RunOptions = {
+  readonly onEscape?: () => void;
+};
+declare function run(program: HasciiProgram): void;
+declare function runWithCallback(program: HasciiProgram, options: RunOptions): void;
+//#endregion
+//#region src/runtime/set-variable.d.ts
+type HasciiState$1 = Record<string, HasciiValue>;
+declare function setVariable(state: HasciiState$1, path: string, value: HasciiValue): HasciiState$1;
+//#endregion
+//#region src/runtime/state.d.ts
+type HasciiRuntimeState = {
+  readonly gameState: Record<string, HasciiValue>;
+  readonly btn: HasciiButtonState;
+  readonly prevBtn: HasciiButtonState;
+};
+declare function createInitialState(program: HasciiProgram): HasciiRuntimeState;
+declare function updateGameState(program: HasciiProgram, state: HasciiRuntimeState, btn: HasciiButtonState): HasciiRuntimeState;
+declare function renderFrame(program: HasciiProgram, state: HasciiRuntimeState): void;
+//#endregion
+export { ANSI, BOX, COLORS, CanvasRegion, DrawState, ERROR_CODES, EffectType, ExecuteResult, GameInstance, HasciiButtonState, HasciiClsStatement, HasciiCompileError, HasciiDrawCommand, HasciiEachStatement, HasciiError, HasciiErrorCode, HasciiExpression, HasciiFillStatement, HasciiFilterStatement, HasciiIfStatement, HasciiMusic, HasciiNoFillStatement, HasciiNoStrokeStatement, HasciiParseError, HasciiPrintStatement, HasciiProgram, HasciiProgramParsed, HasciiPushStatement, HasciiRectStatement, HasciiRuntimeError, HasciiRuntimeState, HasciiSetStatement, HasciiSfxStatement, HasciiState, HasciiStatement, HasciiStrokeStatement, HasciiStrokeStyleStatement, HasciiValidationError, HasciiValue, KeyTimestamps, MusicPattern, RunOptions, Sfx, SfxNote, SourceLocation, SourceMap, SourceMapEntry, StrokeStyle, TickResult, WaveType, compile, createButtonState, createDrawState, createGame, createInitialState, createKeyTimestamps, createSourceMap, disableRawMode, enableRawMode, evaluate, executeStatements, findLocation, formatError, getActiveButtons, getPressedButtons, getSourceLine, hasciiProgramSchema, isSafeKey, isSafePath, isValidKey, line, mapZodCodeToErrorCode, processKeyInput, render, renderCanvas, renderFrame, run, runWithCallback, setVariable, stripAnsi, supportsColor, tick, updateGameState, updateKeyTimestamps };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { $ as line, A as getActiveButtons, B as HasciiRuntimeError, F as compile, G as evaluate, H as findLocation, I as hasciiProgramSchema, J as ERROR_CODES, K as isSafeKey, L as formatError, M as isValidKey, N as processKeyInput, O as createButtonState, P as updateKeyTimestamps, Q as COLORS, R as HasciiError, U as getSourceLine, V as HasciiValidationError, W as createSourceMap, X as ANSI, Y as mapZodCodeToErrorCode, Z as BOX, _ as createDrawState, a as updateGameState, d as renderCanvas, et as stripAnsi, f as render, g as tick, h as createGame, i as renderFrame, j as getPressedButtons, k as createKeyTimestamps, m as enableRawMode, n as runWithCallback, p as disableRawMode, q as isSafePath, r as createInitialState, t as run, tt as supportsColor, v as executeStatements, y as setVariable, z as HasciiParseError } from "./run-mrITeQUl.mjs";
+
+export { ANSI, BOX, COLORS, ERROR_CODES, HasciiError, HasciiParseError, HasciiRuntimeError, HasciiValidationError, compile, createButtonState, createDrawState, createGame, createInitialState, createKeyTimestamps, createSourceMap, disableRawMode, enableRawMode, evaluate, executeStatements, findLocation, formatError, getActiveButtons, getPressedButtons, getSourceLine, hasciiProgramSchema, isSafeKey, isSafePath, isValidKey, line, mapZodCodeToErrorCode, processKeyInput, render, renderCanvas, renderFrame, run, runWithCallback, setVariable, stripAnsi, supportsColor, tick, updateGameState, updateKeyTimestamps };