@lokascript/semantic 1.0.0

package/src/generators/profiles/tl.ts

@@ -0,0 +1,128 @@
+/**
+ * Tagalog Language Profile
+ *
+ * VSO word order, prepositions, space-separated.
+ */
+
+import type { LanguageProfile } from './types';
+
+export const tagalogProfile: LanguageProfile = {
+  code: 'tl',
+  name: 'Tagalog',
+  nativeName: 'Tagalog',
+  direction: 'ltr',
+  wordOrder: 'VSO',
+  markingStrategy: 'preposition',
+  usesSpaces: true,
+  defaultVerbForm: 'base',
+  verb: {
+    position: 'start',
+    subjectDrop: true,
+  },
+  references: {
+    me: 'ako', // "I/me"
+    it: 'ito', // "it"
+    you: 'ikaw', // "you"
+    result: 'resulta', // "result"
+    event: 'pangyayari', // "event"
+    target: 'target', // "target"
+    body: 'body',
+  },
+  possessive: {
+    marker: 'ng', // Linker used in possessive constructions
+    markerPosition: 'between',
+    keywords: {
+      // Tagalog uses postposed possessive pronouns
+      // "my" - ko (clitic), akin (emphatic)
+      ko: 'me',
+      akin: 'me',
+      // "your" - mo (clitic), iyo (emphatic)
+      mo: 'you',
+      iyo: 'you',
+      // "its/his/her" - niya (clitic), kaniya (emphatic)
+      niya: 'it',
+      kaniya: 'it',
+    },
+  },
+  roleMarkers: {
+    destination: { primary: 'sa', position: 'before' }, // "to/into"
+    source: { primary: 'mula_sa', position: 'before' }, // "from"
+    patient: { primary: '', position: 'before' },
+    style: { primary: 'nang', position: 'before' }, // manner marker
+  },
+  keywords: {
+    // Class/Attribute operations
+    toggle: { primary: 'palitan', alternatives: ['itoggle'], normalized: 'toggle' },
+    add: { primary: 'idagdag', alternatives: ['magdagdag'], normalized: 'add' },
+    remove: { primary: 'alisin', alternatives: ['tanggalin'], normalized: 'remove' },
+    // Content operations
+    put: { primary: 'ilagay', alternatives: ['maglagay'], normalized: 'put' },
+    append: { primary: 'idagdag_sa_dulo', normalized: 'append' },
+    prepend: { primary: 'idagdag_sa_simula', normalized: 'prepend' },
+    take: { primary: 'kumuha', normalized: 'take' },
+    make: { primary: 'gumawa', alternatives: ['lumikha'], normalized: 'make' },
+    clone: { primary: 'kopyahin', normalized: 'clone' },
+    swap: { primary: 'magpalit', normalized: 'swap' },
+    morph: { primary: 'baguhin', normalized: 'morph' },
+    // Variable operations
+    set: { primary: 'itakda', alternatives: ['magtakda'], normalized: 'set' },
+    get: { primary: 'kumuha', alternatives: ['kunin'], normalized: 'get' },
+    increment: { primary: 'dagdagan', alternatives: ['taasan'], normalized: 'increment' },
+    decrement: { primary: 'bawasan', alternatives: ['ibaba'], normalized: 'decrement' },
+    log: { primary: 'itala', normalized: 'log' },
+    // Visibility
+    show: { primary: 'ipakita', alternatives: ['magpakita'], normalized: 'show' },
+    hide: { primary: 'itago', alternatives: ['magtago'], normalized: 'hide' },
+    transition: { primary: 'lumipat', normalized: 'transition' },
+    // Events
+    on: { primary: 'kapag', alternatives: ['kung', 'sa'], normalized: 'on' },
+    trigger: { primary: 'magpatugtog', normalized: 'trigger' },
+    send: { primary: 'ipadala', alternatives: ['magpadala'], normalized: 'send' },
+    // DOM focus
+    focus: { primary: 'ituon', normalized: 'focus' },
+    blur: { primary: 'alisin_tuon', normalized: 'blur' },
+    // Navigation
+    go: { primary: 'pumunta', alternatives: ['punta'], normalized: 'go' },
+    // Async
+    wait: { primary: 'maghintay', alternatives: ['hintay'], normalized: 'wait' },
+    fetch: { primary: 'kunin', normalized: 'fetch' },
+    settle: { primary: 'magpatahimik', normalized: 'settle' },
+    // Control flow
+    if: { primary: 'kung', alternatives: ['kapag'], normalized: 'if' },
+    when: { primary: 'kapag', normalized: 'when' },
+    where: { primary: 'kung_saan', normalized: 'where' },
+    else: { primary: 'kung_hindi', alternatives: ['kundi'], normalized: 'else' },
+    repeat: { primary: 'ulitin', alternatives: ['paulit-ulit'], normalized: 'repeat' },
+    for: { primary: 'para_sa', normalized: 'for' },
+    while: { primary: 'habang', normalized: 'while' },
+    continue: { primary: 'magpatuloy', normalized: 'continue' },
+    halt: { primary: 'itigil', alternatives: ['huminto'], normalized: 'halt' },
+    throw: { primary: 'ihagis', alternatives: ['itapon'], normalized: 'throw' },
+    call: { primary: 'tawagan', alternatives: ['tumawag'], normalized: 'call' },
+    return: { primary: 'ibalik', alternatives: ['bumalik'], normalized: 'return' },
+    then: { primary: 'pagkatapos', alternatives: ['saka'], normalized: 'then' },
+    and: { primary: 'at', normalized: 'and' },
+    end: { primary: 'wakas', alternatives: ['tapos'], normalized: 'end' },
+    // Advanced
+    js: { primary: 'js', normalized: 'js' },
+    async: { primary: 'async', normalized: 'async' },
+    tell: { primary: 'sabihin', alternatives: ['magsabi'], normalized: 'tell' },
+    default: { primary: 'default', alternatives: ['unang_halaga'], normalized: 'default' },
+    init: { primary: 'simulan', alternatives: ['magsimula'], normalized: 'init' },
+    behavior: { primary: 'ugali', alternatives: ['kilos'], normalized: 'behavior' },
+    install: { primary: 'ikabit', alternatives: ['mag-install'], normalized: 'install' },
+    measure: { primary: 'sukatin', normalized: 'measure' },
+    // Modifiers
+    into: { primary: 'sa', normalized: 'into' },
+    before: { primary: 'bago', normalized: 'before' },
+    after: { primary: 'matapos', alternatives: ['pagkatapos'], normalized: 'after' },
+    // Event modifiers
+    until: { primary: 'hanggang', normalized: 'until' },
+    event: { primary: 'pangyayari', normalized: 'event' },
+    from: { primary: 'mula', alternatives: ['galing'], normalized: 'from' },
+  },
+  eventHandler: {
+    keyword: { primary: 'kapag', normalized: 'on' },
+    sourceMarker: { primary: 'mula_sa', alternatives: ['galing_sa'], position: 'before' },
+  },
+};

package/src/generators/profiles/turkish.ts

@@ -0,0 +1,124 @@
+/**
+ * Turkish Language Profile
+ *
+ * SOV word order, case suffixes (agglutinative), space-separated.
+ * Features vowel harmony and extensive suffixation.
+ */
+
+import type { LanguageProfile } from './types';
+
+export const turkishProfile: LanguageProfile = {
+  code: 'tr',
+  name: 'Turkish',
+  nativeName: 'Türkçe',
+  direction: 'ltr',
+  wordOrder: 'SOV',
+  markingStrategy: 'case-suffix',
+  usesSpaces: true,
+  verb: {
+    position: 'end',
+    suffixes: ['mek', 'mak', 'yor', 'di', 'miş'],
+    subjectDrop: true,
+  },
+  references: {
+    me: 'ben', // "I/me"
+    it: 'o', // "it"
+    you: 'sen', // "you"
+    result: 'sonuç',
+    event: 'olay',
+    target: 'hedef',
+    body: 'gövde',
+  },
+  possessive: {
+    marker: '', // Turkish uses genitive suffix -in/-ın + possessive suffix
+    markerPosition: 'after-object',
+    usePossessiveAdjectives: true,
+    specialForms: {
+      me: 'benim', // "my" (genitive of "ben")
+      it: 'onun', // "its"
+      you: 'senin', // "your"
+    },
+    keywords: {
+      benim: 'me', // my
+      senin: 'you', // your
+      onun: 'it', // its
+    },
+  },
+  roleMarkers: {
+    patient: { primary: 'i', alternatives: ['ı', 'u', 'ü'], position: 'after' }, // Accusative
+    destination: { primary: 'e', alternatives: ['a', 'de', 'da', 'te', 'ta'], position: 'after' }, // Dative/Locative
+    source: { primary: 'den', alternatives: ['dan', 'ten', 'tan'], position: 'after' }, // Ablative
+    style: { primary: 'le', alternatives: ['la', 'yle', 'yla'], position: 'after' }, // Instrumental
+    event: { primary: 'i', alternatives: ['ı', 'u', 'ü'], position: 'after' }, // Event as accusative
+  },
+  keywords: {
+    // Class/Attribute operations
+    toggle: { primary: 'değiştir', alternatives: ['aç/kapat'], normalized: 'toggle' },
+    add: { primary: 'ekle', normalized: 'add' },
+    remove: { primary: 'kaldır', alternatives: ['sil'], normalized: 'remove' },
+    // Content operations
+    put: { primary: 'koy', normalized: 'put' },
+    append: { primary: 'ekle', normalized: 'append' },
+    take: { primary: 'al', normalized: 'take' },
+    make: { primary: 'yap', normalized: 'make' },
+    clone: { primary: 'kopyala', normalized: 'clone' },
+    swap: { primary: 'değiştir', alternatives: ['takas'], normalized: 'swap' },
+    morph: { primary: 'dönüştür', alternatives: ['şekil değiştir'], normalized: 'morph' },
+    // Variable operations
+    set: { primary: 'ayarla', alternatives: ['yap', 'belirle'], normalized: 'set' },
+    get: { primary: 'al', normalized: 'get' },
+    increment: { primary: 'artır', normalized: 'increment' },
+    decrement: { primary: 'azalt', normalized: 'decrement' },
+    log: { primary: 'kaydet', normalized: 'log' },
+    // Visibility
+    show: { primary: 'göster', normalized: 'show' },
+    hide: { primary: 'gizle', normalized: 'hide' },
+    transition: { primary: 'geçiş', normalized: 'transition' },
+    // Events
+    on: { primary: 'üzerinde', alternatives: ['olduğunda', 'zaman'], normalized: 'on' },
+    trigger: { primary: 'tetikle', normalized: 'trigger' },
+    send: { primary: 'gönder', normalized: 'send' },
+    // DOM focus
+    focus: { primary: 'odak', normalized: 'focus' },
+    blur: { primary: 'bulanık', normalized: 'blur' },
+    // Navigation
+    go: { primary: 'git', normalized: 'go' },
+    // Async
+    wait: { primary: 'bekle', normalized: 'wait' },
+    fetch: { primary: 'getir', normalized: 'fetch' },
+    settle: { primary: 'sabitlen', normalized: 'settle' },
+    // Control flow
+    if: { primary: 'eğer', normalized: 'if' },
+    when: { primary: 'iken', alternatives: ['durumunda', 'olduğunda'], normalized: 'when' },
+    where: { primary: 'nerede', normalized: 'where' },
+    else: { primary: 'yoksa', normalized: 'else' },
+    repeat: { primary: 'tekrarla', normalized: 'repeat' },
+    for: { primary: 'için', normalized: 'for' },
+    while: { primary: 'iken', normalized: 'while' },
+    continue: { primary: 'devam', normalized: 'continue' },
+    halt: { primary: 'durdur', normalized: 'halt' },
+    throw: { primary: 'fırlat', normalized: 'throw' },
+    call: { primary: 'çağır', normalized: 'call' },
+    return: { primary: 'dön', normalized: 'return' },
+    then: { primary: 'sonra', alternatives: ['ardından', 'daha sonra'], normalized: 'then' },
+    and: { primary: 've', alternatives: ['ayrıca', 'hem de'], normalized: 'and' },
+    end: { primary: 'son', alternatives: ['bitiş', 'bitti'], normalized: 'end' },
+    // Advanced
+    js: { primary: 'js', normalized: 'js' },
+    async: { primary: 'asenkron', normalized: 'async' },
+    tell: { primary: 'söyle', normalized: 'tell' },
+    default: { primary: 'varsayılan', normalized: 'default' },
+    init: { primary: 'başlat', normalized: 'init' },
+    behavior: { primary: 'davranış', normalized: 'behavior' },
+    install: { primary: 'yükle', normalized: 'install' },
+    measure: { primary: 'ölç', normalized: 'measure' },
+    // Modifiers
+    into: { primary: 'içine', normalized: 'into' },
+    before: { primary: 'önce', normalized: 'before' },
+    after: { primary: 'sonra', normalized: 'after' },
+    // Event modifiers (for repeat until event)
+    until: { primary: 'kadar', normalized: 'until' },
+    event: { primary: 'olay', normalized: 'event' },
+    from: { primary: '-den', alternatives: ['-dan'], normalized: 'from' },
+  },
+};

package/src/generators/profiles/types.ts

@@ -0,0 +1,165 @@
+/**
+ * Language Profile Types
+ *
+ * Type definitions for language profiles, separated for tree-shaking.
+ */
+
+import type { SemanticRole } from '../../types';
+
+/**
+ * Word order in a language (for declarative statements).
+ */
+export type WordOrder = 'SVO' | 'SOV' | 'VSO' | 'VOS' | 'OSV' | 'OVS';
+
+/**
+ * How grammatical relationships are marked.
+ */
+export type MarkingStrategy = 'preposition' | 'postposition' | 'particle' | 'case-suffix';
+
+/**
+ * A grammatical marker (preposition, particle, etc.) for a semantic role.
+ */
+export interface RoleMarker {
+  /** Primary marker for this role */
+  readonly primary: string;
+  /** Alternative markers that also work */
+  readonly alternatives?: string[];
+  /** Position relative to the role value */
+  readonly position: 'before' | 'after';
+}
+
+/**
+ * Verb form configuration for a language.
+ */
+export interface VerbConfig {
+  /** Position of verb in the sentence */
+  readonly position: 'start' | 'end' | 'second';
+  /** Common verb suffixes/conjugations to recognize */
+  readonly suffixes?: string[];
+  /** Whether the language commonly drops subjects */
+  readonly subjectDrop?: boolean;
+}
+
+/**
+ * Configuration for possessive expression construction.
+ * Defines how "X's property" is expressed in a language.
+ */
+export interface PossessiveConfig {
+  /** Possessive marker (e.g., "'s" in English, "の" in Japanese) */
+  readonly marker: string;
+  /** Position of marker: 'after-object' (X's Y), 'between' (X の Y), 'before-property' */
+  readonly markerPosition: 'after-object' | 'between' | 'before-property';
+  /** Special possessive forms (e.g., 'me' → 'my' in English) */
+  readonly specialForms?: Record<string, string>;
+  /** Whether to use possessive adjectives instead of marker (e.g., Spanish mi/tu/su) */
+  readonly usePossessiveAdjectives?: boolean;
+  /**
+   * Possessive keywords mapped to their corresponding reference.
+   * Used by pattern-matcher to recognize possessive expressions.
+   * Example: { my: 'me', your: 'you', its: 'it' }
+   */
+  readonly keywords?: Record<string, string>;
+}
+
+/**
+ * Complete language profile for pattern generation.
+ */
+export interface LanguageProfile {
+  /** ISO 639-1 language code */
+  readonly code: string;
+  /** Human-readable language name */
+  readonly name: string;
+  /** Native name */
+  readonly nativeName: string;
+  /** Text direction */
+  readonly direction: 'ltr' | 'rtl';
+  /** Primary word order */
+  readonly wordOrder: WordOrder;
+  /** How this language marks grammatical roles */
+  readonly markingStrategy: MarkingStrategy;
+  /** Markers for each semantic role */
+  readonly roleMarkers: Partial<Record<SemanticRole, RoleMarker>>;
+  /** Verb configuration */
+  readonly verb: VerbConfig;
+  /** Command keyword translations */
+  readonly keywords: Record<string, KeywordTranslation>;
+  /** Whether the language uses spaces between words */
+  readonly usesSpaces: boolean;
+  /** Special tokenization notes */
+  readonly tokenization?: TokenizationConfig;
+  /** Reference translations (me, it, you, etc.) */
+  readonly references?: Record<string, string>;
+  /** Possessive expression configuration */
+  readonly possessive?: PossessiveConfig;
+  /** Event handler pattern configuration (for simple SVO languages) */
+  readonly eventHandler?: EventHandlerConfig;
+  /**
+   * Default verb form for command keywords. Defaults to 'infinitive'.
+   *
+   * Based on software UI localization research:
+   * - 'infinitive': Spanish, French, German, Portuguese, Russian (industry standard)
+   * - 'imperative': Polish
+   * - 'base': English, Japanese, Korean (no distinction or same form)
+   *
+   * Individual keywords can override this via KeywordTranslation.form
+   */
+  readonly defaultVerbForm?: VerbForm;
+}
+
+/**
+ * Configuration for event handler pattern generation.
+ * Used by simple SVO languages that don't need hand-crafted patterns.
+ */
+export interface EventHandlerConfig {
+  /** Primary event keyword (e.g., 'on', 'bei', 'sur') */
+  readonly keyword: KeywordTranslation;
+  /** Source filter marker (e.g., 'from', 'von', 'de') */
+  readonly sourceMarker: RoleMarker;
+  /** Conditional keyword (e.g., 'when', 'wenn', 'quand') */
+  readonly conditionalKeyword?: KeywordTranslation;
+}
+
+/**
+ * Verb form used for command keywords.
+ *
+ * Based on software localization research:
+ * - 'infinitive': Standard for most languages (Spanish, French, German, Russian)
+ *   Example: "Guardar", "Enregistrer", "Speichern"
+ * - 'imperative': Used by some languages (Polish)
+ *   Example: "Zapisz", "Otwórz"
+ * - 'base': For languages where forms are identical (English, Japanese, Korean)
+ *   or where the distinction doesn't apply
+ */
+export type VerbForm = 'infinitive' | 'imperative' | 'base';
+
+/**
+ * Translation of a command keyword.
+ */
+export interface KeywordTranslation {
+  /** Primary translation (used for output/rendering) */
+  readonly primary: string;
+  /** Alternative forms for parsing (conjugations, synonyms, informal variants) */
+  readonly alternatives?: string[];
+  /** Normalized English form for internal matching */
+  readonly normalized?: string;
+  /**
+   * The grammatical form of 'primary'. Defaults to 'infinitive'.
+   * This documents the form used and enables future form-switching features.
+   * - 'infinitive': Dictionary form (alternar, basculer) - industry standard
+   * - 'imperative': Command form (alterna, bascule) - for Polish, etc.
+   * - 'base': Same form for both (toggle, トグル) - English, Japanese, Korean
+   */
+  readonly form?: VerbForm;
+}
+
+/**
+ * Special tokenization configuration.
+ */
+export interface TokenizationConfig {
+  /** Particles to recognize (for particle languages) */
+  readonly particles?: string[];
+  /** Prefixes to recognize (for prefixing languages) */
+  readonly prefixes?: string[];
+  /** Word boundary detection strategy */
+  readonly boundaryStrategy?: 'space' | 'particle' | 'character';
+}