@lokascript/domain-learn 2.1.0

package/dist/index.d.cts

@@ -0,0 +1,441 @@
+import * as _lokascript_framework from '@lokascript/framework';
+import { PatternGenLanguageProfile, LanguageTokenizer, SemanticNode, CodeGenerator, MultilingualDSL } from '@lokascript/framework';
+
+/**
+ * Domain-Learn Types
+ *
+ * Types for the learning domain DSL, extending the framework with
+ * communicative functions, morphology tables, and sentence rendering.
+ */
+/** The 7 communicative functions that exercises can target */
+type CommunicativeFunction = 'commanding' | 'describing' | 'narrating' | 'questioning' | 'negating' | 'planning' | 'progressing';
+declare const ALL_FUNCTIONS: readonly CommunicativeFunction[];
+/** The 15 core verbs in the learning domain */
+type CoreVerb = 'add' | 'remove' | 'toggle' | 'put' | 'set' | 'show' | 'hide' | 'get' | 'wait' | 'fetch' | 'send' | 'go' | 'increment' | 'decrement' | 'take';
+declare const ALL_VERBS: readonly CoreVerb[];
+type SemanticRole = 'patient' | 'destination' | 'source' | 'instrument' | 'possessive' | 'manner' | 'style';
+type VerbValence = 'intransitive' | 'transitive' | 'ditransitive';
+interface CommandProfile {
+    verb: CoreVerb;
+    valence: VerbValence;
+    targetRole: SemanticRole | null;
+    hasPatient: boolean;
+}
+interface SentenceFrame {
+    function: CommunicativeFunction;
+    template: string;
+    verbForm: string;
+    example: string;
+}
+interface LanguageFrames {
+    code: string;
+    wordOrder: 'SVO' | 'SOV' | 'VSO';
+    frames: SentenceFrame[];
+}
+interface RenderedSentence {
+    language: string;
+    function: CommunicativeFunction;
+    sentence: string;
+    verbForm: string;
+    verbValue: string;
+}
+interface InterlinearGloss {
+    tokens: string[];
+    roles: string[];
+    english: string[];
+}
+interface EnglishForms {
+    base: string;
+    thirdPerson: string;
+    past: string;
+    pastParticiple: string;
+    presentParticiple: string;
+}
+interface JapaneseForms {
+    dictionary: string;
+    verbClass: 'godan' | 'ichidan' | 'suru' | 'kuru' | 'special';
+    stem: string;
+    masu: string;
+    mashita: string;
+    ta: string;
+    te: string;
+    nai: string;
+    masen: string;
+    potential: string;
+    volitional: string;
+    ba: string;
+    tara: string;
+}
+interface SpanishPersonForms {
+    yo: string;
+    tu: string;
+    el: string;
+    nosotros: string;
+    vosotros: string;
+    ellos: string;
+}
+interface SpanishForms {
+    infinitive: string;
+    verbClass: 'ar' | 'er' | 'ir';
+    irregular: boolean;
+    present: SpanishPersonForms;
+    preterite: SpanishPersonForms;
+    imperfect: SpanishPersonForms;
+    future: SpanishPersonForms;
+    imperative: {
+        tu: string;
+        usted: string;
+        ustedes: string;
+    };
+    gerund: string;
+    pastParticiple: {
+        ms: string;
+        fs: string;
+        mp: string;
+        fp: string;
+    };
+}
+interface ArabicPersonForms {
+    howa: string;
+    hiya: string;
+    anta: string;
+    anti: string;
+    ana: string;
+    hum: string;
+    nahnu: string;
+}
+interface ArabicForms {
+    root: string;
+    form: 'I' | 'II' | 'III' | 'IV' | 'V' | 'VI' | 'VII' | 'VIII' | 'X';
+    past: ArabicPersonForms;
+    present: ArabicPersonForms;
+    imperative: {
+        ms: string;
+        fs: string;
+        mp: string;
+    };
+    activeParticiple: string;
+    passiveParticiple: string;
+    masdar: string;
+}
+interface ChineseForms {
+    base: string;
+    pinyin: string;
+    patterns: {
+        completed: string;
+        experience: string;
+        progressive: string;
+        future: string;
+        negPresent: string;
+        negPast: string;
+    };
+}
+interface KoreanForms {
+    dictionary: string;
+    verbClass: 'hada' | 'native' | 'special';
+    stem: string;
+    hapnida: string;
+    haesseumnida: string;
+    haeyo: string;
+    haesseoyo: string;
+    imperative: string;
+    past: string;
+    negative: string;
+    progressive: string;
+    future: string;
+}
+interface FrenchPersonForms {
+    je: string;
+    tu: string;
+    il: string;
+    nous: string;
+    vous: string;
+    ils: string;
+}
+interface FrenchForms {
+    infinitive: string;
+    imperative: {
+        tu: string;
+        vous: string;
+    };
+    present: FrenchPersonForms;
+    passeCompose: {
+        il: string;
+        je: string;
+    };
+    imparfait: {
+        il: string;
+    };
+    futur: {
+        il: string;
+    };
+    gerondif: string;
+}
+interface TurkishForms {
+    dictionary: string;
+    imperative: {
+        sen: string;
+        siz: string;
+    };
+    present: {
+        ben: string;
+        sen: string;
+        o: string;
+        biz: string;
+        siz: string;
+        onlar: string;
+    };
+    past: {
+        o: string;
+        ben: string;
+    };
+    future: {
+        o: string;
+    };
+    negative: {
+        o: string;
+    };
+    progressive: {
+        o: string;
+    };
+    gerund: string;
+}
+interface GermanPersonForms {
+    ich: string;
+    du: string;
+    er: string;
+    wir: string;
+    ihr: string;
+    sie: string;
+}
+interface GermanForms {
+    infinitive: string;
+    separablePrefix: string;
+    imperative: {
+        du: string;
+        Sie: string;
+    };
+    present: GermanPersonForms;
+    past: {
+        ich: string;
+        er: string;
+    };
+    perfect: {
+        er: string;
+    };
+    future: {
+        er: string;
+    };
+    presentParticiple: string;
+}
+interface PortuguesePersonForms {
+    eu: string;
+    voce: string;
+    ele: string;
+    nos: string;
+    voces: string;
+    eles: string;
+}
+interface PortugueseForms {
+    infinitive: string;
+    imperative: {
+        voce: string;
+        voces: string;
+    };
+    present: PortuguesePersonForms;
+    preterite: {
+        ele: string;
+        eu: string;
+    };
+    imperfect: {
+        ele: string;
+    };
+    future: {
+        ele: string;
+    };
+    gerund: string;
+}
+type AnyForms = EnglishForms | JapaneseForms | SpanishForms | ArabicForms | ChineseForms | KoreanForms | FrenchForms | TurkishForms | GermanForms | PortugueseForms;
+
+interface LearnLanguageProfile {
+    /** Base framework profile for pattern generation */
+    patternProfile: PatternGenLanguageProfile;
+    /** Morphology table: verb → conjugation forms */
+    morphologyTable: Record<string, AnyForms>;
+    /** Sentence frames per communicative function */
+    frames: LanguageFrames;
+    /** Default sentence subject */
+    defaultSubject: string;
+}
+
+declare const allSchemas: _lokascript_framework.CommandSchema[];
+
+declare const enProfile: LearnLanguageProfile;
+
+declare const jaProfile: LearnLanguageProfile;
+
+declare const esProfile: LearnLanguageProfile;
+
+declare const arProfile: LearnLanguageProfile;
+
+declare const zhProfile: LearnLanguageProfile;
+
+declare const koProfile: LearnLanguageProfile;
+
+declare const frProfile: LearnLanguageProfile;
+
+declare const trProfile: LearnLanguageProfile;
+
+declare const deProfile: LearnLanguageProfile;
+
+declare const ptProfile: LearnLanguageProfile;
+
+/**
+ * Language Profiles Index
+ *
+ * Re-exports all 10 language profiles and provides a registry lookup.
+ */
+
+/** All profiles indexed by language code */
+declare const ALL_PROFILES: Record<string, LearnLanguageProfile>;
+
+/**
+ * Learn Domain Tokenizers
+ *
+ * Language-specific tokenizers for learning domain input (10 languages).
+ * Created via the framework's createSimpleTokenizer factory.
+ *
+ * These tokenizers handle:
+ * - Command verb keyword classification
+ * - Role marker particle/preposition classification
+ * - CSS selector recognition (#id, .class)
+ * - Non-Latin script handling (Japanese, Arabic, Korean, Chinese)
+ */
+
+declare const EnglishLearnTokenizer: LanguageTokenizer;
+declare const JapaneseLearnTokenizer: LanguageTokenizer;
+declare const SpanishLearnTokenizer: LanguageTokenizer;
+declare const ArabicLearnTokenizer: LanguageTokenizer;
+declare const ChineseLearnTokenizer: LanguageTokenizer;
+declare const KoreanLearnTokenizer: LanguageTokenizer;
+declare const FrenchLearnTokenizer: LanguageTokenizer;
+declare const TurkishLearnTokenizer: LanguageTokenizer;
+declare const GermanLearnTokenizer: LanguageTokenizer;
+declare const PortugueseLearnTokenizer: LanguageTokenizer;
+
+/**
+ * Learn Code Generator — The Inverted Generator
+ *
+ * Unlike domain-sql (natural language → SQL), this generator produces
+ * natural language sentences WITH morphology applied as its "compiled output".
+ *
+ * The standard CodeGenerator.generate() interface returns the commanding form
+ * in English. The extended generateForFunction() method produces sentences in
+ * any language × communicative function combination.
+ */
+
+interface ResolvedMarker {
+    marker: string;
+    position: 'before' | 'after';
+}
+declare function resolveMarker(verb: string, role: string, language: string): ResolvedMarker;
+declare function attachMarker(value: string, resolved: ResolvedMarker): string;
+declare function registerProfile(code: string, profile: LearnLanguageProfile): void;
+declare function getProfile(code: string): LearnLanguageProfile | undefined;
+/**
+ * Generate a sentence for a SemanticNode in a specific language and
+ * communicative function.
+ */
+declare function generateForFunction(node: SemanticNode, fn: CommunicativeFunction, language: string): RenderedSentence | null;
+/**
+ * Standard CodeGenerator interface — returns the commanding form in English.
+ * This satisfies the framework's CodeGenerator contract.
+ */
+declare const learnCodeGenerator: CodeGenerator;
+/** Render across all communicative functions for a language */
+declare function generateAllFunctions(node: SemanticNode, language: string): RenderedSentence[];
+/** Render across all registered languages for a single function */
+declare function generateCrossLingual(node: SemanticNode, fn: CommunicativeFunction): RenderedSentence[];
+
+/**
+ * Learn Renderer — SemanticNode → DSL text in any language
+ *
+ * Inverse of the parser: converts a parsed SemanticNode back to
+ * natural-language DSL text. Used for cross-language translation
+ * exercises and round-trip verification.
+ */
+
+/**
+ * Render a SemanticNode as DSL text in the target language.
+ * Produces the commanding form (imperative) of the command.
+ */
+declare function renderLearn(node: SemanticNode, language: string): string;
+
+/**
+ * Gloss Generator — Interlinear Gloss for Learning
+ *
+ * Produces interlinear glosses from a SemanticNode, showing:
+ *   tokens:  target language tokens  ["#buttonに", ".activeを", "追加して"]
+ *   roles:   grammatical labels      ["DEST", "PAT", "VERB"]
+ *   english: English gloss           ["to #button", ".active", "add (imperative)"]
+ *
+ * Glosses help ESL students understand the grammatical function of each
+ * word/particle in context, and help code students understand the mapping
+ * between natural language and programming operations.
+ */
+
+/**
+ * Generate an interlinear gloss for a SemanticNode.
+ */
+declare function generateGloss(node: SemanticNode, fn: CommunicativeFunction, language: string): InterlinearGloss | null;
+
+/**
+ * @lokascript/domain-learn — Multilingual Learning DSL
+ *
+ * A learning domain built on @lokascript/framework that formalizes
+ * the morphology engine: 15 verbs x 10 languages x 7 communicative
+ * functions, with sentence generation, interlinear glosses, and
+ * cross-language rendering.
+ *
+ * Unlike domain-sql (natural language -> SQL), domain-learn's "compiled
+ * output" IS natural language sentences with morphology applied. The
+ * standard CodeGenerator.generate() returns the commanding form in English.
+ * The extended generateForFunction() powers the exercise engine.
+ *
+ * @example
+ * ```typescript
+ * import { createLearnDSL } from '@lokascript/domain-learn';
+ *
+ * const learn = createLearnDSL();
+ *
+ * // Parse multilingual command input
+ * const node = learn.parse('add .active to #button', 'en');
+ *
+ * // Generate sentence in any language x function
+ * import { generateForFunction } from '@lokascript/domain-learn';
+ * generateForFunction(node, 'narrating', 'ja');
+ * // -> { sentence: 'システムは #buttonに .activeを 追加しました', ... }
+ *
+ * // Cross-language translation
+ * learn.translate('add .active to #button', 'en', 'ja');
+ *
+ * // Interlinear gloss
+ * import { generateGloss } from '@lokascript/domain-learn';
+ * generateGloss(node, 'commanding', 'ja');
+ * // -> { tokens: ['#buttonに', '.activeを', '追加して'], roles: ['DEST', 'PAT', 'VERB'], ... }
+ * ```
+ */
+
+/**
+ * Create a multilingual learning DSL instance with all 10 supported languages.
+ * Also registers all language profiles with the sentence generator.
+ */
+declare function createLearnDSL(): MultilingualDSL;
+
+declare const learnScanConfig: {
+    attributes: readonly ["data-learn", "_learn"];
+    scriptTypes: readonly ["text/learn-dsl"];
+    defaultLanguage: string;
+};
+
+export { ALL_FUNCTIONS, ALL_PROFILES, ALL_VERBS, type AnyForms, type ArabicForms, ArabicLearnTokenizer, type ChineseForms, ChineseLearnTokenizer, type CommandProfile, type CommunicativeFunction, type CoreVerb, type EnglishForms, EnglishLearnTokenizer, type FrenchForms, FrenchLearnTokenizer, type GermanForms, GermanLearnTokenizer, type InterlinearGloss, type JapaneseForms, JapaneseLearnTokenizer, type KoreanForms, KoreanLearnTokenizer, type LanguageFrames, type LearnLanguageProfile, type PortugueseForms, PortugueseLearnTokenizer, type RenderedSentence, type SemanticRole, type SentenceFrame, type SpanishForms, SpanishLearnTokenizer, type TurkishForms, TurkishLearnTokenizer, type VerbValence, allSchemas, arProfile, attachMarker, createLearnDSL, deProfile, enProfile, esProfile, frProfile, generateAllFunctions, generateCrossLingual, generateForFunction, generateGloss, getProfile, jaProfile, koProfile, learnCodeGenerator, learnScanConfig, ptProfile, registerProfile, renderLearn, resolveMarker, trProfile, zhProfile };

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @lokascript/domain-learn — Multilingual Learning DSL
+ *
+ * A learning domain built on @lokascript/framework that formalizes
+ * the morphology engine: 15 verbs x 10 languages x 7 communicative
+ * functions, with sentence generation, interlinear glosses, and
+ * cross-language rendering.
+ *
+ * Unlike domain-sql (natural language -> SQL), domain-learn's "compiled
+ * output" IS natural language sentences with morphology applied. The
+ * standard CodeGenerator.generate() returns the commanding form in English.
+ * The extended generateForFunction() powers the exercise engine.
+ *
+ * @example
+ * ```typescript
+ * import { createLearnDSL } from '@lokascript/domain-learn';
+ *
+ * const learn = createLearnDSL();
+ *
+ * // Parse multilingual command input
+ * const node = learn.parse('add .active to #button', 'en');
+ *
+ * // Generate sentence in any language x function
+ * import { generateForFunction } from '@lokascript/domain-learn';
+ * generateForFunction(node, 'narrating', 'ja');
+ * // -> { sentence: 'システムは #buttonに .activeを 追加しました', ... }
+ *
+ * // Cross-language translation
+ * learn.translate('add .active to #button', 'en', 'ja');
+ *
+ * // Interlinear gloss
+ * import { generateGloss } from '@lokascript/domain-learn';
+ * generateGloss(node, 'commanding', 'ja');
+ * // -> { tokens: ['#buttonに', '.activeを', '追加して'], roles: ['DEST', 'PAT', 'VERB'], ... }
+ * ```
+ */
+import { type MultilingualDSL } from '@lokascript/framework';
+/**
+ * Create a multilingual learning DSL instance with all 10 supported languages.
+ * Also registers all language profiles with the sentence generator.
+ */
+export declare function createLearnDSL(): MultilingualDSL;
+export type { CommunicativeFunction, CoreVerb, SemanticRole, VerbValence, CommandProfile, SentenceFrame, LanguageFrames, RenderedSentence, InterlinearGloss, LearnLanguageProfile, EnglishForms, JapaneseForms, SpanishForms, ArabicForms, ChineseForms, KoreanForms, FrenchForms, TurkishForms, GermanForms, PortugueseForms, AnyForms, } from './types';
+export { ALL_FUNCTIONS, ALL_VERBS } from './types';
+export { allSchemas } from './schemas';
+export { ALL_PROFILES, enProfile, jaProfile, esProfile, arProfile, zhProfile, koProfile, frProfile, trProfile, deProfile, ptProfile, } from './profiles';
+export { EnglishLearnTokenizer, JapaneseLearnTokenizer, SpanishLearnTokenizer, ArabicLearnTokenizer, ChineseLearnTokenizer, KoreanLearnTokenizer, FrenchLearnTokenizer, TurkishLearnTokenizer, GermanLearnTokenizer, PortugueseLearnTokenizer, } from './tokenizers';
+export { learnCodeGenerator, generateForFunction, generateAllFunctions, generateCrossLingual, registerProfile, getProfile, resolveMarker, attachMarker, } from './generators/sentence-generator';
+export { renderLearn } from './generators/learn-renderer';
+export { generateGloss } from './generators/gloss-generator';
+export declare const learnScanConfig: {
+    attributes: readonly ["data-learn", "_learn"];
+    scriptTypes: readonly ["text/learn-dsl"];
+    defaultLanguage: string;
+};