@lokascript/semantic 1.0.0

package/src/patterns/decrement/ru.ts

@@ -0,0 +1,58 @@
+/**
+ * Russian Decrement Patterns
+ *
+ * Tree-shakeable: Only included when Russian is imported.
+ * Russian uses infinitive verb forms for commands.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Russian decrement patterns.
+ */
+export function getDecrementPatternsRu(): LanguagePattern[] {
+  return [
+    {
+      id: 'decrement-ru-full',
+      language: 'ru',
+      command: 'decrement',
+      priority: 100,
+      template: {
+        format: 'уменьшить {patient} на {quantity}',
+        tokens: [
+          { type: 'literal', value: 'уменьшить', alternatives: ['уменьши'] },
+          { type: 'role', role: 'patient' },
+          {
+            type: 'group',
+            optional: true,
+            tokens: [
+              { type: 'literal', value: 'на' },
+              { type: 'role', role: 'quantity' },
+            ],
+          },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: { marker: 'на', default: { type: 'literal', value: 1 } },
+      },
+    },
+    {
+      id: 'decrement-ru-simple',
+      language: 'ru',
+      command: 'decrement',
+      priority: 90,
+      template: {
+        format: 'уменьшить {patient}',
+        tokens: [
+          { type: 'literal', value: 'уменьшить', alternatives: ['уменьши'] },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: { default: { type: 'literal', value: 1 } },
+      },
+    },
+  ];
+}

package/src/patterns/decrement/th.ts

@@ -0,0 +1,49 @@
+/**
+ * Thai Decrement Patterns
+ *
+ * Patterns for parsing "decrement" command in Thai.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+export function getDecrementPatternsTh(): LanguagePattern[] {
+  return [
+    // Simple pattern: ลดค่า :counter
+    {
+      id: 'decrement-th-simple',
+      language: 'th',
+      command: 'decrement',
+      priority: 100,
+      template: {
+        format: 'ลดค่า {patient}',
+        tokens: [
+          { type: 'literal', value: 'ลดค่า' },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+      },
+    },
+    // With quantity: ลดค่า :counter ด้วย 5
+    {
+      id: 'decrement-th-with-quantity',
+      language: 'th',
+      command: 'decrement',
+      priority: 95,
+      template: {
+        format: 'ลดค่า {patient} ด้วย {quantity}',
+        tokens: [
+          { type: 'literal', value: 'ลดค่า' },
+          { type: 'role', role: 'patient' },
+          { type: 'literal', value: 'ด้วย' },
+          { type: 'role', role: 'quantity' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: { marker: 'ด้วย', position: 3 },
+      },
+    },
+  ];
+}

package/src/patterns/decrement/tl.ts

@@ -0,0 +1,30 @@
+/**
+ * Tagalog Decrement Patterns
+ *
+ * Patterns for parsing "decrement" command in Tagalog.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+export function getDecrementPatternsTl(): LanguagePattern[] {
+  return [
+    // TODO: Add patterns for decrement
+    // Example:
+    // {
+    //   id: 'decrement-tl-simple',
+    //   language: 'tl',
+    //   command: 'decrement',
+    //   priority: 100,
+    //   template: {
+    //     format: 'TODO {patient}',
+    //     tokens: [
+    //       { type: 'literal', value: 'TODO' },
+    //       { type: 'role', role: 'patient' },
+    //     ],
+    //   },
+    //   extraction: {
+    //     patient: { position: 1 },
+    //   },
+    // },
+  ];
+}

package/src/patterns/decrement/tr.ts

@@ -0,0 +1,48 @@
+/**
+ * Turkish Decrement Patterns
+ *
+ * Hand-crafted patterns for "decrement" command.
+ * Turkish: counter azalt (SOV order)
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Turkish decrement patterns.
+ */
+export function getDecrementPatternsTr(): LanguagePattern[] {
+  return [
+    {
+      id: 'decrement-tr-full',
+      language: 'tr',
+      command: 'decrement',
+      priority: 100,
+      template: {
+        format: '{patient} azalt',
+        tokens: [
+          { type: 'role', role: 'patient', expectedTypes: ['selector', 'reference', 'expression'] },
+          { type: 'literal', value: 'azalt', alternatives: ['azaltmak', 'düşür', 'decrement'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 0 },
+      },
+    },
+    {
+      id: 'decrement-tr-svo',
+      language: 'tr',
+      command: 'decrement',
+      priority: 90,
+      template: {
+        format: 'azalt {patient}',
+        tokens: [
+          { type: 'literal', value: 'azalt', alternatives: ['azaltmak'] },
+          { type: 'role', role: 'patient', expectedTypes: ['selector', 'reference', 'expression'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+      },
+    },
+  ];
+}

package/src/patterns/decrement/uk.ts

@@ -0,0 +1,58 @@
+/**
+ * Ukrainian Decrement Patterns
+ *
+ * Tree-shakeable: Only included when Ukrainian is imported.
+ * Ukrainian uses infinitive verb forms for commands.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Ukrainian decrement patterns.
+ */
+export function getDecrementPatternsUk(): LanguagePattern[] {
+  return [
+    {
+      id: 'decrement-uk-full',
+      language: 'uk',
+      command: 'decrement',
+      priority: 100,
+      template: {
+        format: 'зменшити {patient} на {quantity}',
+        tokens: [
+          { type: 'literal', value: 'зменшити', alternatives: ['зменш'] },
+          { type: 'role', role: 'patient' },
+          {
+            type: 'group',
+            optional: true,
+            tokens: [
+              { type: 'literal', value: 'на' },
+              { type: 'role', role: 'quantity' },
+            ],
+          },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: { marker: 'на', default: { type: 'literal', value: 1 } },
+      },
+    },
+    {
+      id: 'decrement-uk-simple',
+      language: 'uk',
+      command: 'decrement',
+      priority: 90,
+      template: {
+        format: 'зменшити {patient}',
+        tokens: [
+          { type: 'literal', value: 'зменшити', alternatives: ['зменш'] },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: { default: { type: 'literal', value: 1 } },
+      },
+    },
+  ];
+}

package/src/patterns/decrement/vi.ts

@@ -0,0 +1,61 @@
+/**
+ * Vietnamese Decrement Patterns
+ *
+ * Tree-shakeable: Only included when Vietnamese is imported.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Vietnamese decrement patterns.
+ */
+export function getDecrementPatternsVi(): LanguagePattern[] {
+  return [
+    {
+      id: 'decrement-vi-full',
+      language: 'vi',
+      command: 'decrement',
+      priority: 100,
+      template: {
+        format: 'giảm {target} đi {amount}',
+        tokens: [
+          { type: 'literal', value: 'giảm', alternatives: ['giảm đi'] },
+          { type: 'role', role: 'patient' },
+          {
+            type: 'group',
+            optional: true,
+            tokens: [
+              { type: 'literal', value: 'đi', alternatives: ['xuống'] },
+              { type: 'role', role: 'quantity' },
+            ],
+          },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: {
+          marker: 'đi',
+          markerAlternatives: ['xuống'],
+          default: { type: 'literal', value: '1' },
+        },
+      },
+    },
+    {
+      id: 'decrement-vi-simple',
+      language: 'vi',
+      command: 'decrement',
+      priority: 90,
+      template: {
+        format: 'giảm {target}',
+        tokens: [
+          { type: 'literal', value: 'giảm', alternatives: ['giảm đi'] },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: { default: { type: 'literal', value: '1' } },
+      },
+    },
+  ];
+}

package/src/patterns/decrement/zh.ts

@@ -0,0 +1,32 @@
+/**
+ * Chinese Decrement Patterns
+ *
+ * Hand-crafted patterns for "decrement" command.
+ * Chinese: 减少 counter
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Chinese decrement patterns.
+ */
+export function getDecrementPatternsZh(): LanguagePattern[] {
+  return [
+    {
+      id: 'decrement-zh-full',
+      language: 'zh',
+      command: 'decrement',
+      priority: 100,
+      template: {
+        format: '减少 {patient}',
+        tokens: [
+          { type: 'literal', value: '减少', alternatives: ['递减', '减', '降低', 'decrement'] },
+          { type: 'role', role: 'patient', expectedTypes: ['selector', 'reference', 'expression'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+      },
+    },
+  ];
+}

package/src/patterns/en.ts

@@ -0,0 +1,302 @@
+/**
+ * English Patterns Module
+ *
+ * Builds all patterns for English language.
+ * This module is imported by languages/en.ts and only includes English patterns.
+ */
+
+import type { LanguagePattern } from '../types';
+import { englishProfile } from '../generators/profiles/english';
+import { generatePatternsForLanguage } from '../generators/pattern-generator';
+
+// Import directly from per-language files for tree-shaking
+import { getTogglePatternsEn } from './toggle/en';
+import { getPutPatternsEn } from './put/en';
+import { getEventHandlerPatternsEn } from './event-handler/en';
+
+// =============================================================================
+// Hand-crafted English-only patterns
+// =============================================================================
+
+/**
+ * English: "fetch /url as json" with response type.
+ */
+const fetchWithResponseTypeEnglish: LanguagePattern = {
+  id: 'fetch-en-with-response-type',
+  language: 'en',
+  command: 'fetch',
+  priority: 90,
+  template: {
+    format: 'fetch {source} as {responseType}',
+    tokens: [
+      { type: 'literal', value: 'fetch' },
+      { type: 'role', role: 'source', expectedTypes: ['literal', 'expression'] },
+      { type: 'literal', value: 'as' },
+      { type: 'role', role: 'responseType', expectedTypes: ['literal', 'expression'] },
+    ],
+  },
+  extraction: {
+    source: { position: 1 },
+    responseType: { marker: 'as' },
+  },
+};
+
+/**
+ * English: "fetch /url" without "from" preposition.
+ */
+const fetchSimpleEnglish: LanguagePattern = {
+  id: 'fetch-en-simple',
+  language: 'en',
+  command: 'fetch',
+  priority: 80,
+  template: {
+    format: 'fetch {source}',
+    tokens: [
+      { type: 'literal', value: 'fetch' },
+      { type: 'role', role: 'source' },
+    ],
+  },
+  extraction: {
+    source: { position: 1 },
+  },
+};
+
+/**
+ * English: "swap <strategy> <target>" without prepositions.
+ */
+const swapSimpleEnglish: LanguagePattern = {
+  id: 'swap-en-handcrafted',
+  language: 'en',
+  command: 'swap',
+  priority: 110,
+  template: {
+    format: 'swap {method} {destination}',
+    tokens: [
+      { type: 'literal', value: 'swap' },
+      { type: 'role', role: 'method' },
+      { type: 'role', role: 'destination' },
+    ],
+  },
+  extraction: {
+    method: { position: 1 },
+    destination: { position: 2 },
+  },
+};
+
+/**
+ * English: "repeat until event pointerup from document"
+ */
+const repeatUntilEventFromEnglish: LanguagePattern = {
+  id: 'repeat-en-until-event-from',
+  language: 'en',
+  command: 'repeat',
+  priority: 120,
+  template: {
+    format: 'repeat until event {event} from {source}',
+    tokens: [
+      { type: 'literal', value: 'repeat' },
+      { type: 'literal', value: 'until' },
+      { type: 'literal', value: 'event' },
+      { type: 'role', role: 'event', expectedTypes: ['literal', 'expression'] },
+      { type: 'literal', value: 'from' },
+      { type: 'role', role: 'source', expectedTypes: ['selector', 'reference', 'expression'] },
+    ],
+  },
+  extraction: {
+    event: { marker: 'event' },
+    source: { marker: 'from' },
+    loopType: { default: { type: 'literal', value: 'until-event' } },
+  },
+};
+
+/**
+ * English: "repeat until event pointerup"
+ */
+const repeatUntilEventEnglish: LanguagePattern = {
+  id: 'repeat-en-until-event',
+  language: 'en',
+  command: 'repeat',
+  priority: 110,
+  template: {
+    format: 'repeat until event {event}',
+    tokens: [
+      { type: 'literal', value: 'repeat' },
+      { type: 'literal', value: 'until' },
+      { type: 'literal', value: 'event' },
+      { type: 'role', role: 'event', expectedTypes: ['literal', 'expression'] },
+    ],
+  },
+  extraction: {
+    event: { marker: 'event' },
+    loopType: { default: { type: 'literal', value: 'until-event' } },
+  },
+};
+
+/**
+ * English: "set {target} to {value}" with possessive syntax support
+ */
+const setPossessiveEnglish: LanguagePattern = {
+  id: 'set-en-possessive',
+  language: 'en',
+  command: 'set',
+  priority: 100,
+  template: {
+    format: 'set {destination} to {patient}',
+    tokens: [
+      { type: 'literal', value: 'set' },
+      {
+        type: 'role',
+        role: 'destination',
+        expectedTypes: ['property-path', 'selector', 'reference', 'expression'],
+      },
+      { type: 'literal', value: 'to' },
+      { type: 'role', role: 'patient', expectedTypes: ['literal', 'expression', 'reference'] },
+    ],
+  },
+  extraction: {
+    destination: { position: 1 },
+    patient: { marker: 'to' },
+  },
+};
+
+/**
+ * English: "for {variable} in {collection}"
+ */
+const forEnglish: LanguagePattern = {
+  id: 'for-en-basic',
+  language: 'en',
+  command: 'for',
+  priority: 100,
+  template: {
+    format: 'for {patient} in {source}',
+    tokens: [
+      { type: 'literal', value: 'for' },
+      { type: 'role', role: 'patient', expectedTypes: ['expression', 'reference'] },
+      { type: 'literal', value: 'in' },
+      { type: 'role', role: 'source', expectedTypes: ['selector', 'expression', 'reference'] },
+    ],
+  },
+  extraction: {
+    patient: { position: 1 },
+    source: { marker: 'in' },
+    loopType: { default: { type: 'literal', value: 'for' } },
+  },
+};
+
+/**
+ * English: "if {condition}"
+ */
+const ifEnglish: LanguagePattern = {
+  id: 'if-en-basic',
+  language: 'en',
+  command: 'if',
+  priority: 100,
+  template: {
+    format: 'if {condition}',
+    tokens: [
+      { type: 'literal', value: 'if' },
+      { type: 'role', role: 'condition', expectedTypes: ['expression', 'reference', 'selector'] },
+    ],
+  },
+  extraction: {
+    condition: { position: 1 },
+  },
+};
+
+/**
+ * English: "unless {condition}"
+ */
+const unlessEnglish: LanguagePattern = {
+  id: 'unless-en-basic',
+  language: 'en',
+  command: 'unless',
+  priority: 100,
+  template: {
+    format: 'unless {condition}',
+    tokens: [
+      { type: 'literal', value: 'unless' },
+      { type: 'role', role: 'condition', expectedTypes: ['expression', 'reference', 'selector'] },
+    ],
+  },
+  extraction: {
+    condition: { position: 1 },
+  },
+};
+
+/**
+ * English: "in 2s toggle .active" - Natural temporal delay
+ */
+const temporalInEnglish: LanguagePattern = {
+  id: 'temporal-en-in',
+  language: 'en',
+  command: 'wait',
+  priority: 95,
+  template: {
+    format: 'in {duration}',
+    tokens: [
+      { type: 'literal', value: 'in' },
+      { type: 'role', role: 'duration', expectedTypes: ['literal', 'expression'] },
+    ],
+  },
+  extraction: {
+    duration: { position: 1 },
+  },
+};
+
+/**
+ * English: "after 2s show #tooltip" - Natural temporal delay
+ */
+const temporalAfterEnglish: LanguagePattern = {
+  id: 'temporal-en-after',
+  language: 'en',
+  command: 'wait',
+  priority: 95,
+  template: {
+    format: 'after {duration}',
+    tokens: [
+      { type: 'literal', value: 'after' },
+      { type: 'role', role: 'duration', expectedTypes: ['literal', 'expression'] },
+    ],
+  },
+  extraction: {
+    duration: { position: 1 },
+  },
+};
+
+// =============================================================================
+// Build All English Patterns
+// =============================================================================
+
+/**
+ * Build all English patterns.
+ * Called once when the English language module is imported.
+ */
+export function buildEnglishPatterns(): LanguagePattern[] {
+  const patterns: LanguagePattern[] = [];
+
+  // 1. Hand-crafted patterns
+  patterns.push(...getTogglePatternsEn());
+  patterns.push(...getPutPatternsEn());
+  patterns.push(...getEventHandlerPatternsEn());
+
+  // 2. English-only hand-crafted patterns
+  patterns.push(
+    fetchWithResponseTypeEnglish,
+    fetchSimpleEnglish,
+    swapSimpleEnglish,
+    repeatUntilEventFromEnglish,
+    repeatUntilEventEnglish,
+    setPossessiveEnglish,
+    forEnglish,
+    ifEnglish,
+    unlessEnglish,
+    temporalInEnglish,
+    temporalAfterEnglish
+  );
+
+  // 3. Generated patterns for English
+  const generatedPatterns = generatePatternsForLanguage(englishProfile);
+  patterns.push(...generatedPatterns);
+
+  return patterns;
+}