peachsim 0.1.673 → 0.1.675

package/src/kotlin-host.ts

@@ -410,6 +410,7 @@ export async function kotlinAppArtifact(
     'PeachEntry.kt': entrySource([]),
     'PeachViews.kt': viewsSource([]),
     'PeachAppEntry.kt': appEntry([]),
+    ...appResourceSources(app),
   }
   const shims = [
     ...kotlinSources(path.join(moduleRoot, 'Sources')),
@@ -435,6 +436,103 @@ export async function kotlinAppArtifact(
   )
 }
 
+// the module's R class in its namespace and the string, plurals and array
+// tables Resources reads. an id is 0x7f, the type, then the entry in name
+// order. a device's ids also count the module's other resource types and the
+// resources its libraries merge in, which Peach does not build, so the
+// numbers themselves differ
+function appResourceSources(app: KotlinAppProject): Record<string, string> {
+  const escapes: Record<string, string> = {
+    '\\': '\\\\',
+    '"': '\\"',
+    $: '\\$',
+    '\n': '\\n',
+    '\r': '\\r',
+    '\t': '\\t',
+  }
+  const literal = (value: string) =>
+    `"${value.replace(
+      /[\\"$\u0000-\u001f]/g,
+      (char) => escapes[char] ?? `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`,
+    )}"`
+  // aapt2 writes a resource name's dots and dashes as underscores in R
+  const field = (name: string) => `\`${name.replace(/[.-]/g, '_')}\``
+  const id = (type: number, entry: number) =>
+    `0x7f${type.toString(16).padStart(2, '0')}${entry.toString(16).padStart(4, '0')}`
+  const kinds = [
+    {
+      type: 'string',
+      table: 'peachAppStrings',
+      value: 'String',
+      resources: app.strings.strings,
+    },
+    {
+      type: 'plurals',
+      table: 'peachAppPlurals',
+      value: 'Map<String, String>',
+      resources: app.strings.plurals,
+    },
+    {
+      type: 'array',
+      table: 'peachAppArrays',
+      value: 'List<String>',
+      resources: app.strings.arrays,
+    },
+  ].map((kind, index) => ({
+    ...kind,
+    entries: kind.resources.map((resource, entry) => ({
+      name: resource.name,
+      id: id(index + 1, entry),
+      values: Object.entries(resource.values).map(
+        ([locale, value]: [
+          string,
+          string | string[] | Partial<Record<string, string>>,
+        ]) =>
+          `${literal(locale)} to ${
+            typeof value === 'string'
+              ? literal(value)
+              : Array.isArray(value)
+                ? `listOf(${value.map(literal).join(', ')})`
+                : `mapOf(${Object.entries(value)
+                    .map(
+                      ([quantity, text]) =>
+                        `${literal(quantity)} to ${literal(text ?? '')}`,
+                    )
+                    .join(', ')})`
+          }`,
+      ),
+    })),
+  }))
+  return {
+    'R.kt': [
+      `package ${app.namespace}`,
+      '',
+      'object R {',
+      ...kinds.flatMap((kind) => [
+        `    object ${kind.type} {`,
+        ...kind.entries.map(
+          (entry) => `        const val ${field(entry.name)}: Int = ${entry.id}`,
+        ),
+        '    }',
+      ]),
+      '}',
+      '',
+    ].join('\n'),
+    'PeachAppResources.kt': [
+      'package dev.peach.app',
+      '',
+      ...kinds.flatMap((kind) => [
+        `internal val ${kind.table}: Map<Int, Map<String, ${kind.value}>> = mapOf(`,
+        ...kind.entries.map(
+          (entry) => `    ${entry.id} to mapOf(${entry.values.join(', ')}),`,
+        ),
+        ')',
+        '',
+      ]),
+    ].join('\n'),
+  }
+}
+
 async function compileKotlin(
   input: {
     root: string

package/src/swift-compile.ts

@@ -229,10 +229,11 @@ export function swiftArtifactHash(
   moduleRoot: string,
 ): string {
   const hash = createHash('sha256')
+  // v7: runtime class lookup uses the same objc class registry as messages
   // v6: app and scene delegate classes compile final
   // (v5: a target declaring resources gets SwiftPM's Bundle.module accessor;
   // v4: sources compile through swiftSourceAsIOS)
-  hash.update(`swift-compile/v6\n${release}\n`)
+  hash.update(`swift-compile/v7\n${release}\n`)
   if (input.oneModule) hash.update('one-module\n')
   hash.update(linkedModuleDigest(moduleRoot))
   for (const file of Object.keys(input.files).sort()) {
@@ -392,6 +393,17 @@ export function swiftSourceAsIOS(source: string): string {
   let copied = 0
   for (const at of tokens) {
     const rest = conditioned.slice(at, at + 400)
+    const imported = /^import\s+CoreImage\.CIFilterBuiltins\b/.exec(rest)
+    if (imported) {
+      out += conditioned.slice(copied, at) + 'import CoreImage'.padEnd(imported[0].length)
+      copied = at + imported[0].length
+      continue
+    }
+    if (/^NSClassFromString\b/.test(rest)) {
+      out += conditioned.slice(copied, at) + '_peachClassFromString'
+      copied = at + 'NSClassFromString'.length
+      continue
+    }
     if (rest.startsWith('class')) {
       const modifiers = conditioned.slice(conditioned.lastIndexOf('\n', at - 1) + 1, at)
       if (DELEGATE_CLASS.test(rest) && !/\b(?:final|open)\b/.test(modifiers)) {
@@ -504,16 +516,25 @@ function swiftCodeScan(source: string): { lineStarts: Set<number>; tokens: numbe
       if (top.parens === 0 && stack.length > 1) stack.pop()
       else top.parens--
       i++
-    } else if (
-      source.startsWith('class', i) &&
-      !/[\w$]/.test(source[i - 1] ?? '') &&
-      !/[\w$]/.test(source[i + 5] ?? '')
-    ) {
-      tokens.push(i)
-      i += 5
     } else {
-      if (char === '@') tokens.push(i)
-      i++
+      const keyword = source.startsWith('class', i)
+        ? 'class'
+        : source.startsWith('import', i)
+          ? 'import'
+          : source.startsWith('NSClassFromString', i)
+            ? 'NSClassFromString'
+            : null
+      if (
+        keyword &&
+        !/[\w$]/.test(source[i - 1] ?? '') &&
+        !/[\w$]/.test(source[i + keyword.length] ?? '')
+      ) {
+        tokens.push(i)
+        i += keyword.length
+      } else {
+        if (char === '@') tokens.push(i)
+        i++
+      }
     }
   }
   return { lineStarts: starts, tokens }

package/src/swift-host.ts

@@ -5,6 +5,7 @@ import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import { swiftToolchainBin } from '../../../src/compile/swiftToolchain'
 import {
   enumerateBundleColors,
   enumerateBundleSymbols,
@@ -642,10 +643,7 @@ export function localSwiftToolchain(
   if (typeof release !== 'string') {
     throw new Error(`swift toolchain manifest at ${moduleRoot} has no release`)
   }
-  const toolchainBin = path.join(
-    os.homedir(),
-    `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`,
-  )
+  const toolchainBin = swiftToolchainBin(release)
   return fs.existsSync(path.join(toolchainBin, 'swift'))
     ? { release, toolchainBin }
     : null