@logic-pad/core 0.1.0

package/dist/data/rules/customRule.js

@@ -0,0 +1,92 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { State } from '../primitives';
+import Rule from './rule';
+class CustomRule extends Rule {
+    /**
+     * A custom rule with a description and thumbnail grid.
+     *
+     * This rule validates answers based on the provided solution.
+     *
+     * @param description - The description of the rule.
+     * @param grid - The thumbnail grid of the rule, preferably 5x4 in size.
+     */
+    constructor(description, grid) {
+        super();
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: description
+        });
+        Object.defineProperty(this, "grid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: grid
+        });
+        this.description = description;
+        this.grid = grid;
+    }
+    get id() {
+        return `custom`;
+    }
+    get explanation() {
+        return this.description;
+    }
+    get configs() {
+        return CustomRule.configs;
+    }
+    createExampleGrid() {
+        return this.grid;
+    }
+    get searchVariants() {
+        return CustomRule.SEARCH_VARIANTS;
+    }
+    validateGrid(_grid) {
+        return { state: State.Incomplete };
+    }
+    copyWith({ description, grid, }) {
+        return new CustomRule(description ?? this.description, grid ?? this.grid);
+    }
+    get validateWithSolution() {
+        return true;
+    }
+}
+Object.defineProperty(CustomRule, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(new GridData(5, 4))
+});
+Object.defineProperty(CustomRule, "configs", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.String,
+            default: 'A *custom* rule',
+            field: 'description',
+            description: 'Description',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Grid,
+            default: CustomRule.EXAMPLE_GRID,
+            field: 'grid',
+            description: 'Thumbnail Grid',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(CustomRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new CustomRule('A *custom* rule', CustomRule.EXAMPLE_GRID).searchVariant(),
+    ]
+});
+export default CustomRule;
+export const instance = new CustomRule('', GridData.create([]));

package/dist/data/rules/foresightRule.d.ts

@@ -0,0 +1,30 @@
+import { AnyConfig } from '../config';
+import GridData from '../grid';
+import { RuleState } from '../primitives';
+import Rule, { SearchVariant } from './rule';
+export default class ForesightRule extends Rule {
+    readonly count: number;
+    readonly regenInterval: number;
+    readonly startFull: boolean;
+    private static readonly EXAMPLE_GRID;
+    private static readonly CONFIGS;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Foresight: Show hints**
+     */
+    constructor(count: number, regenInterval: number, startFull: boolean);
+    get id(): string;
+    get explanation(): string;
+    get visibleWhenSolving(): boolean;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(_grid: GridData): RuleState;
+    get necessaryForCompletion(): boolean;
+    copyWith({ count, regenInterval, startFull, }: {
+        count?: number;
+        regenInterval?: number;
+        startFull?: boolean;
+    }): this;
+}
+export declare const instance: ForesightRule;

package/dist/data/rules/foresightRule.js

@@ -0,0 +1,107 @@
+import { ConfigType } from '../config';
+import GridData from '../grid';
+import { State } from '../primitives';
+import CustomIconSymbol from '../symbols/customIconSymbol';
+import Rule from './rule';
+class ForesightRule extends Rule {
+    /**
+     * **Foresight: Show hints**
+     */
+    constructor(count, regenInterval, startFull) {
+        super();
+        Object.defineProperty(this, "count", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: count
+        });
+        Object.defineProperty(this, "regenInterval", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: regenInterval
+        });
+        Object.defineProperty(this, "startFull", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: startFull
+        });
+        this.count = count;
+        this.regenInterval = regenInterval;
+        this.startFull = startFull;
+    }
+    get id() {
+        return `foresight`;
+    }
+    get explanation() {
+        return `*Foresight:* Show hints`;
+    }
+    get visibleWhenSolving() {
+        return false;
+    }
+    get configs() {
+        return ForesightRule.CONFIGS;
+    }
+    createExampleGrid() {
+        return ForesightRule.EXAMPLE_GRID;
+    }
+    get searchVariants() {
+        return ForesightRule.SEARCH_VARIANTS;
+    }
+    validateGrid(_grid) {
+        return { state: State.Incomplete };
+    }
+    get necessaryForCompletion() {
+        return false;
+    }
+    copyWith({ count, regenInterval, startFull, }) {
+        return new ForesightRule(count ?? this.count, regenInterval ?? this.regenInterval, startFull ?? this.startFull);
+    }
+}
+Object.defineProperty(ForesightRule, "EXAMPLE_GRID", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze(GridData.create(['.']).addSymbol(new CustomIconSymbol('', GridData.create([]), 0, 0, 'MdRemoveRedEye')))
+});
+Object.defineProperty(ForesightRule, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.Number,
+            default: 5,
+            min: 1,
+            field: 'count',
+            description: 'Foresight count',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Number,
+            default: 30,
+            min: 1,
+            field: 'regenInterval',
+            description: 'Regen Interval (seconds)',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Boolean,
+            default: false,
+            field: 'startFull',
+            description: 'Start with full foresight',
+            configurable: true,
+        },
+    ])
+});
+Object.defineProperty(ForesightRule, "SEARCH_VARIANTS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: [
+        new ForesightRule(5, 30, false).searchVariant(),
+    ]
+});
+export default ForesightRule;
+export const instance = new ForesightRule(5, 30, false);

package/dist/data/rules/index.d.ts

@@ -0,0 +1,3 @@
+import Rule from './rule';
+declare const allRules: Map<string, Rule>;
+export { allRules };

package/dist/data/rules/index.js

@@ -0,0 +1,10 @@
+import * as rules from './rules.gen';
+const allRules = new Map();
+function register(prototype) {
+    allRules.set(prototype.id, prototype);
+}
+Object.values(rules).forEach(rule => {
+    if (rule)
+        register(rule);
+});
+export { allRules };

package/dist/data/rules/musicControlLine.d.ts

@@ -0,0 +1,64 @@
+import { AnyConfig } from '../config';
+import Configurable from '../configurable';
+export declare class Row extends Configurable {
+    /**
+     * The note to play at this row, or null to keep the current note from the previous control line.
+     * If this is null from the first control line, the note will be silent.
+     */
+    readonly note: string | null;
+    /**
+     * The velocity to play the note at, or null to keep the current velocity from the previous control line.
+     * Ranges from 0 to 1
+     */
+    readonly velocity: number | null;
+    private static readonly CONFIGS;
+    constructor(
+    /**
+     * The note to play at this row, or null to keep the current note from the previous control line.
+     * If this is null from the first control line, the note will be silent.
+     */
+    note: string | null, 
+    /**
+     * The velocity to play the note at, or null to keep the current velocity from the previous control line.
+     * Ranges from 0 to 1
+     */
+    velocity: number | null);
+    get configs(): readonly AnyConfig[] | null;
+    copyWith({ note, velocity, }: {
+        note?: string | null;
+        velocity?: number | null;
+    }): this;
+}
+export declare class ControlLine extends Configurable {
+    readonly column: number;
+    readonly bpm: number | null;
+    readonly pedal: boolean | null;
+    readonly checkpoint: boolean;
+    readonly rows: readonly Row[];
+    private static readonly CONFIGS;
+    /**
+     * Configure playback settings, taking effect at the given column (inclusive)
+     * @param column The column at which the settings take effect
+     * @param bpm The new beats per minute, or null to keep the current value from the previous control line
+     * @param pedal Whether the pedal is pressed, or null to keep the current value from the previous control line
+     * @param checkpoint Whether this control line is a checkpoint
+     * @param rows The notes to play at each row. This list is automatically resized to match the height of the grid. You may pass in an empty list if none of the rows need to be changed.
+     */
+    constructor(column: number, bpm: number | null, pedal: boolean | null, checkpoint: boolean, rows: readonly Row[]);
+    get configs(): readonly AnyConfig[] | null;
+    copyWith({ column, bpm, pedal, checkpoint, rows, }: {
+        column?: number;
+        bpm?: number | null;
+        pedal?: boolean | null;
+        checkpoint?: boolean;
+        rows?: readonly Row[];
+    }): this;
+    withColumn(column: number): this;
+    withBpm(bpm: number | null): this;
+    withPedal(pedal: boolean | null): this;
+    withCheckpoint(checkpoint: boolean): this;
+    withRows(rows: readonly Row[]): this;
+    equals(other: ControlLine): boolean;
+    get isEmpty(): boolean;
+}
+export declare const instance: undefined;

package/dist/data/rules/musicControlLine.js

@@ -0,0 +1,178 @@
+import { ConfigType } from '../config';
+import Configurable from '../configurable';
+export class Row extends Configurable {
+    constructor(
+    /**
+     * The note to play at this row, or null to keep the current note from the previous control line.
+     * If this is null from the first control line, the note will be silent.
+     */
+    note, 
+    /**
+     * The velocity to play the note at, or null to keep the current velocity from the previous control line.
+     * Ranges from 0 to 1
+     */
+    velocity) {
+        super();
+        Object.defineProperty(this, "note", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: note
+        });
+        Object.defineProperty(this, "velocity", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: velocity
+        });
+        this.note = note;
+        this.velocity = velocity;
+    }
+    get configs() {
+        return Row.CONFIGS;
+    }
+    copyWith({ note, velocity, }) {
+        return new Row(note !== undefined ? note : this.note, velocity !== undefined ? velocity : this.velocity);
+    }
+}
+Object.defineProperty(Row, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.NullableNote,
+            default: 'C4',
+            field: 'note',
+            description: 'Note',
+            configurable: true,
+        },
+        {
+            type: ConfigType.NullableNumber,
+            default: 0.6,
+            min: 0,
+            max: 1,
+            step: 0.2,
+            field: 'velocity',
+            description: 'Velocity',
+            configurable: true,
+        },
+    ])
+});
+export class ControlLine extends Configurable {
+    /**
+     * Configure playback settings, taking effect at the given column (inclusive)
+     * @param column The column at which the settings take effect
+     * @param bpm The new beats per minute, or null to keep the current value from the previous control line
+     * @param pedal Whether the pedal is pressed, or null to keep the current value from the previous control line
+     * @param checkpoint Whether this control line is a checkpoint
+     * @param rows The notes to play at each row. This list is automatically resized to match the height of the grid. You may pass in an empty list if none of the rows need to be changed.
+     */
+    constructor(column, bpm, pedal, checkpoint, rows) {
+        super();
+        Object.defineProperty(this, "column", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: column
+        });
+        Object.defineProperty(this, "bpm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: bpm
+        });
+        Object.defineProperty(this, "pedal", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: pedal
+        });
+        Object.defineProperty(this, "checkpoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: checkpoint
+        });
+        Object.defineProperty(this, "rows", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: rows
+        });
+        this.column = Math.floor(column);
+        this.bpm = bpm;
+        this.pedal = pedal;
+        this.checkpoint = checkpoint;
+        this.rows = rows;
+    }
+    get configs() {
+        return ControlLine.CONFIGS;
+    }
+    copyWith({ column, bpm, pedal, checkpoint, rows, }) {
+        return new ControlLine(column ?? this.column, bpm !== undefined ? bpm : this.bpm, pedal !== undefined ? pedal : this.pedal, checkpoint ?? this.checkpoint, rows ?? this.rows);
+    }
+    withColumn(column) {
+        return this.copyWith({ column });
+    }
+    withBpm(bpm) {
+        return this.copyWith({ bpm });
+    }
+    withPedal(pedal) {
+        return this.copyWith({ pedal });
+    }
+    withCheckpoint(checkpoint) {
+        return this.copyWith({ checkpoint });
+    }
+    withRows(rows) {
+        return this.copyWith({ rows });
+    }
+    equals(other) {
+        return (this.column === other.column &&
+            this.bpm === other.bpm &&
+            this.pedal === other.pedal &&
+            this.checkpoint === other.checkpoint &&
+            this.rows.length === other.rows.length &&
+            this.rows.every((row, i) => {
+                const otherRow = other.rows[i];
+                return row.note === otherRow.note && row.velocity === otherRow.velocity;
+            }));
+    }
+    get isEmpty() {
+        return (this.bpm === null &&
+            this.pedal === null &&
+            !this.checkpoint &&
+            !this.rows.some(row => row.note !== null || row.velocity !== null));
+    }
+}
+Object.defineProperty(ControlLine, "CONFIGS", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: Object.freeze([
+        {
+            type: ConfigType.NullableNumber,
+            default: 120,
+            min: 20,
+            max: 1000,
+            field: 'bpm',
+            description: 'BPM',
+            configurable: true,
+        },
+        {
+            type: ConfigType.NullableBoolean,
+            default: false,
+            field: 'pedal',
+            description: 'Pedal',
+            configurable: true,
+        },
+        {
+            type: ConfigType.Boolean,
+            default: false,
+            field: 'checkpoint',
+            description: 'Checkpoint',
+            configurable: true,
+        },
+    ])
+});
+export const instance = undefined;

package/dist/data/rules/musicGridRule.d.ts

@@ -0,0 +1,46 @@
+import { AnyConfig } from '../config';
+import { GridChangeHandler } from '../events/onGridChange';
+import { GridResizeHandler } from '../events/onGridResize';
+import { SetGridHandler } from '../events/onSetGrid';
+import GridData from '../grid';
+import { RuleState } from '../primitives';
+import { ControlLine } from './musicControlLine';
+import Rule, { SearchVariant } from './rule';
+export default class MusicGridRule extends Rule implements GridChangeHandler, SetGridHandler, GridResizeHandler {
+    readonly controlLines: readonly ControlLine[];
+    readonly track: GridData | null;
+    private static readonly EXAMPLE_GRID;
+    private static readonly CONFIGS;
+    private static readonly SEARCH_VARIANTS;
+    /**
+     * **Music Grid: Listen to the solution**
+     * @param controlLines Denote changes in the playback settings. At least one control line at column 0 should be present to enable playback.
+     * @param track The grid to be played when "listen" is clicked. Set as null to play the solution.
+     */
+    constructor(controlLines: readonly ControlLine[], track: GridData | null);
+    get id(): string;
+    get explanation(): string;
+    get configs(): readonly AnyConfig[] | null;
+    createExampleGrid(): GridData;
+    get searchVariants(): SearchVariant[];
+    validateGrid(_grid: GridData): RuleState;
+    onSetGrid(_oldGrid: GridData, newGrid: GridData): GridData;
+    onGridChange(newGrid: GridData): this;
+    onGridResize(_grid: GridData, mode: 'insert' | 'remove', direction: 'row' | 'column', index: number): this | null;
+    /**
+     * Add or replace a control line.
+     * @param controlLine The control line to set.
+     * @returns A new rule with the control line set.
+     */
+    setControlLine(controlLine: ControlLine): this;
+    withTrack(track: GridData | null): this;
+    copyWith({ controlLines, track, }: {
+        controlLines?: readonly ControlLine[];
+        track?: GridData | null;
+    }): this;
+    get validateWithSolution(): boolean;
+    get isSingleton(): boolean;
+    static mergeControlLines(...lines: ControlLine[]): ControlLine;
+    static deduplicateControlLines(lines: readonly ControlLine[]): ControlLine[];
+}
+export declare const instance: MusicGridRule;