@lokascript/semantic 1.0.0

package/src/patterns/increment/ru.ts

@@ -0,0 +1,58 @@
+/**
+ * Russian Increment Patterns
+ *
+ * Tree-shakeable: Only included when Russian is imported.
+ * Russian uses infinitive verb forms for commands.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Russian increment patterns.
+ */
+export function getIncrementPatternsRu(): LanguagePattern[] {
+  return [
+    {
+      id: 'increment-ru-full',
+      language: 'ru',
+      command: 'increment',
+      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: 'increment-ru-simple',
+      language: 'ru',
+      command: 'increment',
+      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/increment/th.ts

@@ -0,0 +1,49 @@
+/**
+ * Thai Increment Patterns
+ *
+ * Patterns for parsing "increment" command in Thai.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+export function getIncrementPatternsTh(): LanguagePattern[] {
+  return [
+    // Simple pattern: เพิ่มค่า :counter
+    {
+      id: 'increment-th-simple',
+      language: 'th',
+      command: 'increment',
+      priority: 100,
+      template: {
+        format: 'เพิ่มค่า {patient}',
+        tokens: [
+          { type: 'literal', value: 'เพิ่มค่า' },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+      },
+    },
+    // With quantity: เพิ่มค่า :counter ด้วย 5
+    {
+      id: 'increment-th-with-quantity',
+      language: 'th',
+      command: 'increment',
+      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/increment/tl.ts

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

package/src/patterns/increment/tr.ts

@@ -0,0 +1,52 @@
+/**
+ * Turkish Increment Patterns
+ *
+ * Hand-crafted patterns for "increment" command.
+ * Turkish: counter artır (SOV order)
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Turkish increment patterns.
+ */
+export function getIncrementPatternsTr(): LanguagePattern[] {
+  return [
+    {
+      id: 'increment-tr-full',
+      language: 'tr',
+      command: 'increment',
+      priority: 100,
+      template: {
+        format: '{patient} artır',
+        tokens: [
+          { type: 'role', role: 'patient', expectedTypes: ['selector', 'reference', 'expression'] },
+          {
+            type: 'literal',
+            value: 'artır',
+            alternatives: ['artir', 'artırmak', 'artirmak', 'arttır', 'increment'],
+          },
+        ],
+      },
+      extraction: {
+        patient: { position: 0 },
+      },
+    },
+    {
+      id: 'increment-tr-svo',
+      language: 'tr',
+      command: 'increment',
+      priority: 90,
+      template: {
+        format: 'artır {patient}',
+        tokens: [
+          { type: 'literal', value: 'artır', alternatives: ['artir', 'artırmak'] },
+          { type: 'role', role: 'patient', expectedTypes: ['selector', 'reference', 'expression'] },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+      },
+    },
+  ];
+}

package/src/patterns/increment/uk.ts

@@ -0,0 +1,58 @@
+/**
+ * Ukrainian Increment Patterns
+ *
+ * Tree-shakeable: Only included when Ukrainian is imported.
+ * Ukrainian uses infinitive verb forms for commands.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Ukrainian increment patterns.
+ */
+export function getIncrementPatternsUk(): LanguagePattern[] {
+  return [
+    {
+      id: 'increment-uk-full',
+      language: 'uk',
+      command: 'increment',
+      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: 'increment-uk-simple',
+      language: 'uk',
+      command: 'increment',
+      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/increment/vi.ts

@@ -0,0 +1,61 @@
+/**
+ * Vietnamese Increment Patterns
+ *
+ * Tree-shakeable: Only included when Vietnamese is imported.
+ */
+
+import type { LanguagePattern } from '../../types';
+
+/**
+ * Get Vietnamese increment patterns.
+ */
+export function getIncrementPatternsVi(): LanguagePattern[] {
+  return [
+    {
+      id: 'increment-vi-full',
+      language: 'vi',
+      command: 'increment',
+      priority: 100,
+      template: {
+        format: 'tăng {target} thêm {amount}',
+        tokens: [
+          { type: 'literal', value: 'tăng', alternatives: ['tăng lên'] },
+          { type: 'role', role: 'patient' },
+          {
+            type: 'group',
+            optional: true,
+            tokens: [
+              { type: 'literal', value: 'thêm', alternatives: ['lên'] },
+              { type: 'role', role: 'quantity' },
+            ],
+          },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: {
+          marker: 'thêm',
+          markerAlternatives: ['lên'],
+          default: { type: 'literal', value: '1' },
+        },
+      },
+    },
+    {
+      id: 'increment-vi-simple',
+      language: 'vi',
+      command: 'increment',
+      priority: 90,
+      template: {
+        format: 'tăng {target}',
+        tokens: [
+          { type: 'literal', value: 'tăng', alternatives: ['tăng lên'] },
+          { type: 'role', role: 'patient' },
+        ],
+      },
+      extraction: {
+        patient: { position: 1 },
+        quantity: { default: { type: 'literal', value: '1' } },
+      },
+    },
+  ];
+}

package/src/patterns/increment/zh.ts

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

package/src/patterns/index.ts

@@ -0,0 +1,84 @@
+/**
+ * Pattern Registry
+ *
+ * Central registry for all language patterns.
+ * Provides lookup by language and command type.
+ *
+ * Architecture:
+ * - builders.ts: Pattern building and generation logic
+ * - registry.ts: Pattern cache and lookup functions
+ * - languages/en/: English-only hand-crafted patterns
+ * - toggle/, put/, event-handler/: Per-command patterns by language
+ */
+
+import type { LanguagePattern } from '../types';
+import type { LanguageProfile } from '../generators/language-profiles';
+
+// =============================================================================
+// Re-exports from builders and registry
+// =============================================================================
+
+// Pattern building
+export {
+  buildPatternsForLanguage,
+  buildAllPatterns,
+  getGeneratedPatterns,
+  getHandcraftedLanguages,
+} from './builders';
+
+// Pattern lookup and cache
+export {
+  allPatterns,
+  getAllPatterns,
+  getPatternsForLanguage,
+  getPatternsForLanguageAndCommand,
+  getSupportedLanguages,
+  getSupportedCommands,
+  getPatternById,
+  getPatternStats,
+  clearPatternCache,
+} from './registry';
+
+export type { PatternStats } from './registry';
+
+// =============================================================================
+// Re-exports from per-command pattern directories
+// =============================================================================
+
+// Per-language getter functions (tree-shakeable)
+export { getTogglePatternsForLanguage } from './toggle/index';
+export { getPutPatternsForLanguage } from './put/index';
+export { getEventHandlerPatternsForLanguage } from './event-handler/index';
+export { getGrammarTransformedPatternsForLanguage } from './grammar-transformed/index';
+
+// Event handler utilities
+export { eventNameTranslations, normalizeEventName } from './event-handler/shared';
+
+// =============================================================================
+// Registry Pattern Generator Setup
+// =============================================================================
+// Set up the pattern generator for the registry so that non-English languages
+// work correctly when using the full bundle. This enables the registry's
+// getPatternsForLanguage to fall back to buildPatternsForLanguage when patterns
+// aren't directly registered.
+
+import { setPatternGenerator } from '../registry';
+import { buildPatternsForLanguage } from './builders';
+
+// Wrapper to match the registry's expected signature (profile -> patterns)
+function patternGeneratorForProfile(profile: LanguageProfile): LanguagePattern[] {
+  return buildPatternsForLanguage(profile.code);
+}
+
+// Register the pattern generator with the registry
+// This allows the registry to generate patterns for any registered language
+setPatternGenerator(patternGeneratorForProfile);
+
+// =============================================================================
+// Backwards Compatibility Notes
+// =============================================================================
+// NOTE: togglePatterns, putPatterns, eventHandlerPatterns arrays are NOT
+// re-exported from this file to enable tree-shaking. Import them directly:
+//   import { togglePatterns } from './patterns/toggle';
+//   import { putPatterns } from './patterns/put';
+//   import { eventHandlerPatterns } from './patterns/event-handler';

package/src/patterns/languages/en/control-flow.ts

@@ -0,0 +1,93 @@
+/**
+ * English Control Flow Patterns
+ *
+ * Hand-crafted patterns for for, if, and unless commands.
+ */
+
+import type { LanguagePattern } from '../../../types';
+
+/**
+ * English: "for {variable} in {collection}"
+ * Basic for-each iteration pattern.
+ *
+ * Examples:
+ * - for item in items
+ * - for x in .elements
+ * - for user in users
+ */
+export 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'] }, // Loop variable
+      { type: 'literal', value: 'in' },
+      { type: 'role', role: 'source', expectedTypes: ['selector', 'expression', 'reference'] }, // Collection
+    ],
+  },
+  extraction: {
+    patient: { position: 1 },
+    source: { marker: 'in' },
+    loopType: { default: { type: 'literal', value: 'for' } },
+  },
+};
+
+/**
+ * English: "if {condition}"
+ * Basic conditional pattern. Body parsing handled by main parser.
+ *
+ * Examples:
+ * - if active toggle .class
+ * - if x > 5 then ... end
+ * - if myVar
+ */
+export 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}"
+ * Negated conditional pattern. Body parsing handled by main parser.
+ *
+ * Examples:
+ * - unless disabled submit
+ * - unless x == 0 then ... end
+ */
+export 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 },
+  },
+};
+
+/**
+ * All English control flow patterns.
+ */
+export const controlFlowPatternsEn: LanguagePattern[] = [forEnglish, ifEnglish, unlessEnglish];

package/src/patterns/languages/en/fetch.ts

@@ -0,0 +1,62 @@
+/**
+ * English Fetch Patterns
+ *
+ * Hand-crafted patterns for fetch command with response type support.
+ */
+
+import type { LanguagePattern } from '../../../types';
+
+/**
+ * English: "fetch /url as json" with response type.
+ * This pattern has higher priority to capture the "as json" modifier.
+ */
+export const fetchWithResponseTypeEnglish: LanguagePattern = {
+  id: 'fetch-en-with-response-type',
+  language: 'en',
+  command: 'fetch',
+  priority: 90, // Higher than simple pattern (80) to capture "as" modifier first
+  template: {
+    format: 'fetch {source} as {responseType}',
+    tokens: [
+      { type: 'literal', value: 'fetch' },
+      { type: 'role', role: 'source', expectedTypes: ['literal', 'expression'] },
+      { type: 'literal', value: 'as' },
+      // json/text/html are identifiers not keywords, so we need to accept 'expression' type
+      { type: 'role', role: 'responseType', expectedTypes: ['literal', 'expression'] },
+    ],
+  },
+  extraction: {
+    source: { position: 1 },
+    responseType: { marker: 'as' },
+  },
+};
+
+/**
+ * English: "fetch /url" without "from" preposition.
+ * Official hyperscript allows bare URL without "from".
+ * Lower priority so it's tried after the response type pattern.
+ */
+export const fetchSimpleEnglish: LanguagePattern = {
+  id: 'fetch-en-simple',
+  language: 'en',
+  command: 'fetch',
+  priority: 80, // Lower than response type pattern (90) - fallback when "as" not present
+  template: {
+    format: 'fetch {source}',
+    tokens: [
+      { type: 'literal', value: 'fetch' },
+      { type: 'role', role: 'source' },
+    ],
+  },
+  extraction: {
+    source: { position: 1 },
+  },
+};
+
+/**
+ * All English fetch patterns.
+ */
+export const fetchPatternsEn: LanguagePattern[] = [
+  fetchWithResponseTypeEnglish,
+  fetchSimpleEnglish,
+];

package/src/patterns/languages/en/index.ts

@@ -0,0 +1,42 @@
+/**
+ * English-Only Patterns
+ *
+ * Re-exports all English-specific hand-crafted patterns.
+ * These patterns are only included when English is the target language.
+ */
+
+import type { LanguagePattern } from '../../../types';
+
+import { fetchPatternsEn } from './fetch';
+import { swapPatternsEn } from './swap';
+import { repeatPatternsEn } from './repeat';
+import { setPatternsEn } from './set';
+import { controlFlowPatternsEn } from './control-flow';
+import { temporalPatternsEn } from './temporal';
+
+// Re-export individual pattern arrays for selective imports
+export { fetchPatternsEn } from './fetch';
+export { swapPatternsEn } from './swap';
+export { repeatPatternsEn } from './repeat';
+export { setPatternsEn } from './set';
+export { controlFlowPatternsEn } from './control-flow';
+export { temporalPatternsEn } from './temporal';
+
+/**
+ * All English-only hand-crafted patterns combined.
+ */
+export const allEnglishOnlyPatterns: LanguagePattern[] = [
+  ...fetchPatternsEn,
+  ...swapPatternsEn,
+  ...repeatPatternsEn,
+  ...setPatternsEn,
+  ...controlFlowPatternsEn,
+  ...temporalPatternsEn,
+];
+
+/**
+ * Get all English-only hand-crafted patterns.
+ */
+export function getEnglishOnlyPatterns(): LanguagePattern[] {
+  return allEnglishOnlyPatterns;
+}

package/src/patterns/languages/en/repeat.ts

@@ -0,0 +1,67 @@
+/**
+ * English Repeat Patterns
+ *
+ * Hand-crafted patterns for repeat command with event termination.
+ */
+
+import type { LanguagePattern } from '../../../types';
+
+/**
+ * English: "repeat until event pointerup from document"
+ * Full form with event source specification.
+ * Higher priority to capture the complete "until event X from Y" syntax.
+ */
+export const repeatUntilEventFromEnglish: LanguagePattern = {
+  id: 'repeat-en-until-event-from',
+  language: 'en',
+  command: 'repeat',
+  priority: 120, // Highest priority - most specific pattern
+  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"
+ * Simple event termination without source.
+ */
+export const repeatUntilEventEnglish: LanguagePattern = {
+  id: 'repeat-en-until-event',
+  language: 'en',
+  command: 'repeat',
+  priority: 110, // Lower than "from" variant, but higher than quantity-based repeat
+  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' } },
+  },
+};
+
+/**
+ * All English repeat patterns.
+ */
+export const repeatPatternsEn: LanguagePattern[] = [
+  repeatUntilEventFromEnglish,
+  repeatUntilEventEnglish,
+];