peachsim 0.1.2176 → 0.1.2179

package/sdk/ios/System/Library/Frameworks/QuickLook.framework/Headers/QuickLook.h

@@ -0,0 +1,30 @@
+//
+//  QuickLook.h
+//  QuickLook
+//
+//  Copyright (c) 2008-2015 Apple Inc. All rights reserved.
+//
+
+
+#if !defined(__QUICKLOOK_QUICKLOOK__)
+#define __QUICKLOOK_QUICKLOOK__
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <QuickLook/QLBase.h>
+
+#if __OBJC__
+#import <QuickLook/QLPreviewController.h>
+#import <QuickLook/QLPreviewItem.h>
+#import <QuickLook/ARQuickLookPreviewItem.h>
+#import <QuickLook/QLPreviewingController.h>
+#import <QuickLook/QLThumbnailProvider.h>
+#import <QuickLook/QLThumbnailRequest.h>
+#import <QuickLook/QLThumbnailReply.h>
+#import <QuickLook/QLPreviewProvider.h>
+#import <QuickLook/QLPreviewReply.h>
+#import <QuickLook/QLFilePreviewRequest.h>
+#import <QuickLook/QLPreviewSceneActivationConfiguration.h>
+#import <QuickLook/QuickLookUICore.h>
+#endif
+
+#endif

package/sdk/ios/System/Library/Frameworks/QuickLook.framework/Headers/QuickLookUICore.h

@@ -0,0 +1,12 @@
+//
+//  QuickLookUICore.h
+//  QuickLookUICore
+//
+//  Created by Thomas Deniau on 02/07/2021.
+//  Copyright © 2021 com.apple. All rights reserved.
+//
+
+#import <QuickLook/QLBase.h>
+#import <QuickLook/QLPreviewItem.h>
+#import <QuickLook/QLPreviewingController.h>
+#import <QuickLook/ARQuickLookPreviewItem.h>

package/sdk/ios/System/Library/Frameworks/QuickLook.framework/Modules/module.modulemap

@@ -0,0 +1,8 @@
+framework module QuickLook {
+     umbrella header "QuickLook.h"
+
+     export *
+     module * { export * }
+     
+     config_macros USE_PUBLIC_QUICKLOOK_HEADERS
+}

package/src/core-data-entity-classes.ts

@@ -0,0 +1,316 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { parsePlistSource } from './plist'
+
+// the entity classes Xcode's momc writes for `codeGenerationType="class"` and
+// `"category"` entities, from the model alone so any host can run it. every
+// rule here was read from momc 27.1 --action generate (swift 5, iOS 17); a model
+// feature whose output was not observed is refused, never guessed.
+
+type Tag = { name: string; attrs: Record<string, string>; children: Tag[] }
+
+const unescapeXml = (value: string) =>
+  value
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, '&')
+
+// the model format is plain tags and attributes with no text content.
+function parseModel(xml: string): Tag {
+  const root: Tag = { name: '#root', attrs: {}, children: [] }
+  const stack = [root]
+  for (const match of xml.matchAll(
+    /<(\/?)([A-Za-z][\w-]*)((?:\s+[\w:-]+="[^"]*")*)\s*(\/?)>/g,
+  )) {
+    const [, closing, name, attributes, selfClosing] = match
+    if (closing) {
+      stack.pop()
+      continue
+    }
+    const attrs: Record<string, string> = {}
+    for (const attribute of attributes!.matchAll(/([\w:-]+)="([^"]*)"/g))
+      attrs[attribute[1]!] = unescapeXml(attribute[2]!)
+    const tag: Tag = { name: name!, attrs, children: [] }
+    stack.at(-1)!.children.push(tag)
+    if (!selfClosing) stack.push(tag)
+  }
+  return root
+}
+
+const scalarTypes: Record<string, [scalar: string, boxed: string]> = {
+  'Integer 16': ['Int16', 'NSNumber'],
+  'Integer 32': ['Int32', 'NSNumber'],
+  'Integer 64': ['Int64', 'NSNumber'],
+  Double: ['Double', 'NSNumber'],
+  Float: ['Float', 'NSNumber'],
+  Boolean: ['Bool', 'NSNumber'],
+}
+
+const objectTypes: Record<string, string> = {
+  Decimal: 'NSDecimalNumber',
+  String: 'String',
+  Date: 'Date',
+  Binary: 'Data',
+  UUID: 'UUID',
+  URI: 'URL',
+  Undefined: 'NSObject',
+}
+
+const reserved = new Set([
+  'class',
+  'in',
+  'init',
+  'self',
+  'Type',
+  'Protocol',
+  'default',
+  'repeat',
+  'operator',
+  'subscript',
+])
+const identifier = (name: string) => (reserved.has(name) ? `\`${name}\`` : name)
+const capitalized = (name: string) => name.charAt(0).toUpperCase() + name.slice(1)
+
+type ClassName = { name: string; module: string | null }
+const className = (represented: string): ClassName => {
+  const at = represented.lastIndexOf('.')
+  return at < 0
+    ? { name: represented, module: null }
+    : { name: represented.slice(at + 1), module: represented.slice(0, at) }
+}
+
+function refuse(model: string, reason: string): never {
+  throw new Error(`Core Data entity classes are unproven for ${model}: ${reason}`)
+}
+
+const generatedNotice = (file: string) => `//
+//  ${file}
+//
+//  This file was automatically generated and should not be edited.
+//
+`
+
+function entityFiles(model: string, entity: Tag, entities: Map<string, Tag>) {
+  const entityName = entity.attrs.name!
+  const represented = className(entity.attrs.representedClassName!)
+  const codegen = entity.attrs.codeGenerationType
+  const parent = entity.attrs.parentEntity
+    ? entities.get(entity.attrs.parentEntity)
+    : undefined
+  if (entity.attrs.parentEntity && !parent)
+    refuse(
+      model,
+      `${entityName} names the missing parent entity ${entity.attrs.parentEntity}`,
+    )
+  const files: Record<string, string> = {}
+  const base = parent
+    ? className(parent.attrs.representedClassName ?? parent.attrs.name!).name
+    : 'NSManagedObject'
+  if (codegen === 'class') {
+    const file = `${represented.name}+CoreDataClass.swift`
+    files[file] = `${generatedNotice(file)}
+public import Foundation
+public import CoreData
+
+public typealias ${represented.name}CoreDataClassSet = NSSet
+
+${represented.module ? '\n' : `@objc(${represented.name})\n`}public class ${represented.name}: ${base} {
+
+}
+`
+  }
+
+  const imports = new Set<string>()
+  const properties: string[] = []
+  const accessors: string[] = []
+  for (const member of entity.children) {
+    const name = member.attrs.name
+    if (member.name === 'attribute') {
+      const type = member.attrs.attributeType!
+      let swiftType: string
+      const scalar = scalarTypes[type]
+      if (scalar)
+        swiftType =
+          member.attrs.usesScalarValueType === 'NO' ? `${scalar[1]}?` : scalar[0]
+      else if (type === 'Transformable' && member.attrs.customClassName) {
+        const custom = className(member.attrs.customClassName)
+        if (custom.module) imports.add(custom.module)
+        swiftType = `${custom.name}?`
+      } else if (type === 'Transformable') swiftType = 'NSObject?'
+      else if (objectTypes[type]) swiftType = `${objectTypes[type]}?`
+      else refuse(model, `${entityName}.${name} has the attribute type ${type}`)
+      properties.push(
+        `    @NSManaged nonisolated public var ${identifier(name!)}: ${swiftType}`,
+      )
+    } else if (member.name === 'relationship') {
+      const destination = entities.get(member.attrs.destinationEntity!)
+      if (!destination)
+        refuse(
+          model,
+          `${entityName}.${name} names the missing entity ${member.attrs.destinationEntity}`,
+        )
+      const target = className(
+        destination!.attrs.representedClassName ?? destination!.attrs.name!,
+      )
+      if (target.module) imports.add(target.module)
+      if (member.attrs.toMany !== 'YES') {
+        properties.push(
+          `    @NSManaged nonisolated public var ${identifier(name!)}: ${target.name}?`,
+        )
+        continue
+      }
+      const cap = capitalized(name!)
+      const ordered = member.attrs.ordered === 'YES'
+      properties.push(
+        `    @NSManaged nonisolated public var ${identifier(name!)}: ${ordered ? 'NSOrderedSet' : 'NSSet'}?`,
+      )
+      const lines = [
+        `// MARK: Generated accessors for ${name}`,
+        'extension ' + represented.name + ' {',
+        '',
+      ]
+      const add = (selector: string, signature: string) =>
+        lines.push(
+          `    @objc(${selector})`,
+          `    @NSManaged nonisolated public func ${signature}`,
+          '',
+        )
+      if (ordered) {
+        add(
+          `insertObject:in${cap}AtIndex:`,
+          `insertInto${cap}(_ value: ${target.name}, at idx: Int)`,
+        )
+        add(`removeObjectFrom${cap}AtIndex:`, `removeFrom${cap}(at idx: Int)`)
+        add(
+          `insert${cap}:atIndexes:`,
+          `insertInto${cap}(_ values: [${target.name}], at indexes: NSIndexSet)`,
+        )
+        add(`remove${cap}AtIndexes:`, `removeFrom${cap}(at indexes: NSIndexSet)`)
+        add(
+          `replaceObjectIn${cap}AtIndex:withObject:`,
+          `replace${cap}(at idx: Int, with value: ${target.name})`,
+        )
+        add(
+          `replace${cap}AtIndexes:with${cap}:`,
+          `replace${cap}(at indexes: NSIndexSet, with values: [${target.name}])`,
+        )
+      }
+      add(`add${cap}Object:`, `addTo${cap}(_ value: ${target.name})`)
+      add(`remove${cap}Object:`, `removeFrom${cap}(_ value: ${target.name})`)
+      add(`add${cap}:`, `addTo${cap}(_ values: ${ordered ? 'NSOrderedSet' : 'NSSet'})`)
+      add(
+        `remove${cap}:`,
+        `removeFrom${cap}(_ values: ${ordered ? 'NSOrderedSet' : 'NSSet'})`,
+      )
+      lines.push('}', '')
+      accessors.push(lines.join('\n'))
+    } else if (
+      ['fetchedProperty', 'compositeAttribute', 'derivedAttribute'].includes(member.name)
+    )
+      refuse(model, `${entityName} declares a ${member.name}`)
+  }
+
+  const file = `${represented.name}+CoreDataProperties.swift`
+  files[file] = `${generatedNotice(file)}
+public import Foundation
+public import CoreData
+${
+  imports.size > 0
+    ? [...imports]
+        .sort()
+        .map((module) => `import ${module}\n`)
+        .join('')
+    : '\n'
+}
+public typealias ${represented.name}CoreDataPropertiesSet = NSSet
+
+extension ${represented.name} {
+
+    @nonobjc public class func fetchRequest() -> NSFetchRequest<${represented.name}> {
+        return NSFetchRequest<${represented.name}>(entityName: "${entityName}")
+    }
+
+${properties.length > 0 ? `${properties.join('\n')}\n\n` : '\n'}}
+
+${accessors.map((block) => `${block}\n`).join('')}${
+    parent
+      ? ''
+      : `extension ${represented.name} : Identifiable {
+
+}
+`
+  }`
+  return files
+}
+
+/** the swift files momc writes for one compiled model version, keyed by file name. */
+export function coreDataEntityClasses(
+  modelFile: string,
+  model = path.basename(path.dirname(modelFile)),
+) {
+  const root = parseModel(readFileSync(modelFile, 'utf8'))
+  const entities = new Map<string, Tag>()
+  const modelTag = root.children.find((tag) => tag.name === 'model')
+  if (!modelTag) refuse(model, 'the contents file has no model element')
+  for (const tag of modelTag!.children)
+    if (tag.name === 'entity') entities.set(tag.attrs.name!, tag)
+  const files: Record<string, string> = {}
+  for (const entity of entities.values()) {
+    const codegen = entity.attrs.codeGenerationType
+    if (codegen !== 'class' && codegen !== 'category') continue
+    if (!entity.attrs.representedClassName) continue
+    Object.assign(files, entityFiles(model, entity, entities))
+  }
+  return files
+}
+
+/** the current version's contents file of an .xcdatamodeld, or a bare .xcdatamodel's own. */
+export function currentModelContents(modelDirectory: string) {
+  if (modelDirectory.endsWith('.xcdatamodel'))
+    return path.join(modelDirectory, 'contents')
+  const versionFile = path.join(modelDirectory, '.xccurrentversion')
+  const versions = readdirSync(modelDirectory).filter((entry) =>
+    entry.endsWith('.xcdatamodel'),
+  )
+  const named = existsSync(versionFile)
+    ? parsePlistSource(readFileSync(versionFile, 'utf8'))
+    : undefined
+  const current =
+    typeof named === 'object' &&
+    named !== null &&
+    '_XCCurrentVersionName' in named &&
+    typeof named._XCCurrentVersionName === 'string'
+      ? named._XCCurrentVersionName
+      : !existsSync(versionFile) && versions.length === 1
+        ? versions[0]
+        : undefined
+  if (current && versions.includes(current))
+    return path.join(modelDirectory, current, 'contents')
+  // without a named version only a model that generates nothing is safe to skip
+  const generating = versions.filter((version) =>
+    /codeGenerationType="(?:class|category)"/.test(
+      readFileSync(path.join(modelDirectory, version, 'contents'), 'utf8'),
+    ),
+  )
+  if (generating.length > 0)
+    refuse(path.basename(modelDirectory), 'the current model version is not named')
+  return null
+}
+
+/** the entity class sources for every model directory in a target's files, keyed by `<name>`. */
+export function coreDataSources(files: readonly string[]) {
+  const models = new Set<string>()
+  for (const file of files) {
+    const at = file.search(/\.xcdatamodeld(?:[\\/]|$)/)
+    if (at >= 0) models.add(file.slice(0, at + '.xcdatamodeld'.length))
+  }
+  const sources: Record<string, string> = {}
+  for (const directory of [...models].sort()) {
+    const contents = currentModelContents(directory)
+    if (contents)
+      Object.assign(sources, coreDataEntityClasses(contents, path.basename(directory)))
+  }
+  return sources
+}

package/src/swift-host.ts

@@ -14,6 +14,7 @@ import {
   resolveSwiftImageResourceUrls,
 } from '../../sootsim-swift/src/bundleAssets'
 import { compileStringCatalog } from '../../sootsim-swift/src/stringCatalog'
+import { coreDataSources } from './core-data-entity-classes'
 import iosSdk from './ios-sdk-frameworks.json' with { type: 'json' }
 import { type NativeAppIdentity } from './native-app-identity'
 import { readNativeAppIdentityFromXcodeTarget } from './native-app-identity-project'
@@ -815,6 +816,11 @@ async function buildXcodeLayout(root: string): Promise<XcodeLayout | null> {
   }
   const generatedSources: Record<string, string> = {}
   // xcode generates symbols for each target's own catalogs from its own settings
+  // xcode compiles the entity classes of each target's own models into it
+  const coreDataClasses = (files: readonly string[], dir: string) => {
+    for (const [name, text] of Object.entries(coreDataSources(files)))
+      generatedSources[path.posix.join(dir, 'GeneratedCoreData', name)] = text
+  }
   const targetAssetSymbols = (module: XcodeModuleTarget, dir: string) => {
     const plan = planAssetSymbols(
       module.resources.map((file) => path.relative(root, file)),
@@ -827,6 +833,7 @@ async function buildXcodeLayout(root: string): Promise<XcodeLayout | null> {
         assetSymbolText(plan.plan, root)
   }
   targetAssetSymbols(app, XCODE_APP_DIR)
+  coreDataClasses(app.resources, XCODE_APP_DIR)
   for (const framework of app.frameworks) {
     // a framework target that only links products compiles nothing, so it has
     // no module, directory or bundle contents for swiftpm to take as a target
@@ -862,6 +869,7 @@ async function buildXcodeLayout(root: string): Promise<XcodeLayout | null> {
       files.add(file)
     }
     targetAssetSymbols(framework, dir)
+    coreDataClasses(framework.resources, dir)
     targets.push({
       name,
       path: dir,
@@ -1144,6 +1152,10 @@ async function buildXcodeLayout(root: string): Promise<XcodeLayout | null> {
         )
       ] = generatePackageAssetSymbols(catalogs, target.packageDir, target.iosDeployment)
     }
+    coreDataClasses(
+      target.files,
+      target.remote ? path.posix.join(XCODE_PACKAGES_DIR, posix) : posix,
+    )
   }
   // swiftpm assigns a file to one target: a target directory nested in
   // another's is that one's exclusion

package/src/turbo-source.ts

@@ -49,7 +49,7 @@ import {
   installedRendererDependencyGlobs,
   runInstalledTurboCodegen,
 } from './turbo-codegen-intake'
-import { installedXcodeWorkspace } from './xcode-project'
+import { installedXcodeWorkspace, readXcodeAppTarget } from './xcode-project'
 import type { ReactNativeCoreMode } from './react-native-core'
 import type { SwiftCompileInput } from './swift-compile'
 import type { SwiftPackageTarget } from './swift-package'
@@ -1198,6 +1198,20 @@ export async function collectTurboSources(options: {
   // compile key; reading it again is free.
   const compiledSources = new Set<string>()
   const textualSources = new Set<string>()
+  const workspace = installedXcodeWorkspace(options.projectRoot)
+  const installedTargets =
+    workspace && !options.reactNativeCore && !options.reactNativeProvider
+      ? readXcodeAppTarget(workspace, undefined, 'Release', {
+          installedPods: true,
+        }).frameworks
+      : []
+  const fileFlags = new Map(
+    installedTargets.flatMap((target) =>
+      Object.entries(target.objc?.fileFlags ?? {}).map(
+        ([file, flags]): [string, string[]] => [fs.realpathSync(file), flags],
+      ),
+    ),
+  )
   const original = (
     targetName: string,
     label: string,
@@ -1215,6 +1229,38 @@ export async function collectTurboSources(options: {
       (compiled ? compiledSources : textualSources).add(key)
     if (Object.hasOwn(result.files, key)) return key
     const disk = path.join(root, relative)
+    const flags = compiled ? fileFlags.get(fs.realpathSync(disk)) : undefined
+    if (flags?.length) {
+      result.nativeTargets ??= []
+      let native = result.nativeTargets.find(({ name }) => name === targetName)
+      if (!native) {
+        native = {
+          name: targetName,
+          deploymentTarget: null,
+          headers: [],
+          publicHeaders: [],
+          flattensPublicHeaders: false,
+          bridgingHeader: null,
+          prefixHeader: null,
+          headerSearchPaths: [
+            `${targetPath(targetName)}/include`,
+            `${targetPath(TURBO_CORE_TARGET)}/include`,
+          ],
+          userHeaderSearchPaths: [],
+          frameworkSearchPaths: [],
+          headerMaps: [],
+          productHeaders: {},
+          flags: [],
+          importerFlags: [],
+          cxxFlags: [],
+          fileFlags: {},
+          sourceDirectories: {},
+        }
+        result.nativeTargets.push(native)
+      }
+      native.fileFlags[key] = flags
+      native.sourceDirectories[key] = path.posix.dirname(key)
+    }
     const bytes = readPackageFile(root, disk, Infinity)
     const text = bytes.toString('utf8')
     if (!Buffer.from(text).equals(bytes))
@@ -1741,14 +1787,22 @@ export async function collectTurboSources(options: {
     })
     const mappings = podHeaderMappings(pod)
     // CocoaPods flattens a pod's headers: `Name.h` and `<pod>/Name.h`
+    const ambiguousHeaders = new Set<string>()
     const header = (
       names: string[],
       entry: { label: string; root: string; relative: string },
     ) => {
       for (const name of names) {
+        if (ambiguousHeaders.has(name)) continue
         const prior = headers.get(name)
-        if (prior && prior.relative !== entry.relative)
+        if (prior && (prior.root !== entry.root || prior.relative !== entry.relative)) {
+          if (!name.includes('/') && prior.label !== entry.label) {
+            headers.delete(name)
+            ambiguousHeaders.add(name)
+            continue
+          }
           throw new Error(`${label}: two pod headers are named ${name}`)
+        }
         headers.set(name, entry)
       }
     }
@@ -1838,15 +1892,39 @@ export async function collectTurboSources(options: {
       const moduleNames = installed ? podspecList(installed.text, 'module_name') : null
       if (moduleNames === 'computed')
         throw new Error(`${dep.name}: module_name must come from the installed pod`)
-      const resolved = installed
-        ? {
-            name: installed.name,
-            moduleName: moduleNames?.[0] ?? installed.name,
-            root: installed.root,
-            files: podFiles(installed),
-            defines: [],
-          }
-        : await resolveExternalTurboPod(dep.name, dep.requirements, dep.subspecs)
+      const installedTarget = installedTargets.find(
+        (target) => target.name === dep.name && target.podRoot,
+      )
+      const installedRoot = installedTarget?.podRoot
+        ? fs.realpathSync(installedTarget.podRoot)
+        : undefined
+      const resolved =
+        installedTarget && installedRoot
+          ? {
+              name: installedTarget.name,
+              moduleName: installedTarget.moduleName,
+              root: installedRoot,
+              files: [
+                ...new Set([
+                  ...installedTarget.allSources,
+                  ...(installedTarget.objc?.headers ?? []),
+                  ...(installedTarget.objc?.publicHeaders ?? []),
+                ]),
+              ].flatMap((file) => {
+                const relative = relativeInside(installedRoot, fs.realpathSync(file))
+                return relative === null ? [] : [relative.split(path.sep).join('/')]
+              }),
+              defines: [],
+            }
+          : installed
+            ? {
+                name: installed.name,
+                moduleName: moduleNames?.[0] ?? installed.name,
+                root: installed.root,
+                files: podFiles(installed),
+                defines: [],
+              }
+            : await resolveExternalTurboPod(dep.name, dep.requirements, dep.subspecs)
       if (!resolved) continue
       if (provider.reactModulesOnly && resolved.files.some((f) => f.endsWith('.swift')))
         continue