bare-stow 0.1.9 → 0.2.0

package/lib/language/kotlin.js

@@ -0,0 +1,109 @@
+const path = require('path')
+
+exports.name = 'kotlin'
+
+exports.options = function options(given = {}) {
+  const { package: name, ...unknown } = given
+
+  for (const option of Object.keys(unknown)) {
+    throw new Error(`Unknown option '${option}' for language 'kotlin'`)
+  }
+
+  if (name === undefined) throw new Error("Option 'package' is required for language 'kotlin'")
+
+  if (!/^[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/.test(name)) {
+    throw new Error(`'${name}' is not a valid Kotlin package name`)
+  }
+
+  return { package: name }
+}
+
+// The bundle is an asset of the module, under the directory of its package as
+// the assets of every module of the application share one namespace.
+exports.layout = function layout(out, options) {
+  const dir = options.package.replace(/\./g, '/')
+
+  return {
+    harness: new URL(`src/main/kotlin/${dir}/Harness.kt`, out),
+    artifacts: new URL(`src/main/assets/${dir}/`, out),
+    name: options.package,
+    manifest: new URL('build.gradle', out),
+    addons: new URL('src/main/addons/', out),
+    resources: new URL('src/main/assets/', out)
+  }
+}
+
+exports.sibling = function sibling(url, name) {
+  return new URL(capitalize(name) + '.kt', url)
+}
+
+// Assets are referenced by their path within the assets of the application.
+exports.reference = function reference(from, to) {
+  const assets = to.pathname.lastIndexOf('/src/main/assets/')
+
+  if (assets !== -1) return to.pathname.slice(assets + '/src/main/assets/'.length)
+
+  return path.posix.relative(path.posix.dirname(from.pathname), to.pathname)
+}
+
+// The dependencies of Kotlin generators map Maven coordinates without a version
+// to the version that the module uses. They are part of the API of the module,
+// as the harness exposes their types.
+exports.manifest = function manifest({ name, dependencies, addons = [] }) {
+  const apis = Object.entries(dependencies).map(
+    ([coordinates, version]) => `  api ${JSON.stringify(coordinates + ':' + version)}`
+  )
+
+  // Linked addons are native libraries in a directory per ABI, along with the
+  // archives of any Java classes they use.
+  const libraries = [
+    ...new Set(
+      addons
+        .filter((addon) => addon.endsWith('.so'))
+        .map((addon) => path.posix.dirname(path.posix.dirname(addon)))
+    )
+  ]
+
+  for (const addon of addons) {
+    if (addon.endsWith('.jar')) apis.push(`  api files(${JSON.stringify(addon)})`)
+  }
+
+  const sourceSets = libraries.length
+    ? `
+
+  sourceSets {
+    main {
+${libraries.map((dir) => `      jniLibs.directories.add(${JSON.stringify(dir)})`).join('\n')}
+    }
+  }`
+    : ''
+
+  // Projects that opt out of the Kotlin support built into AGP 9, such as those
+  // of Expo, need the Kotlin plugin to compile the harness.
+  return `\
+plugins {
+  id "com.android.library"
+}
+
+if (findProperty("android.builtInKotlin") == "false") {
+  apply plugin: "org.jetbrains.kotlin.android"
+}
+
+android {
+  namespace = ${JSON.stringify(name)}
+  compileSdk = 36
+
+  defaultConfig {
+    minSdk = 29
+  }${sourceSets}
+}
+
+dependencies {
+${apis.join('\n')}
+}
+`
+}
+
+function capitalize(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1)
+}

package/lib/language/python.js

@@ -0,0 +1,65 @@
+const path = require('path')
+
+exports.name = 'python'
+
+exports.options = function options(given = {}) {
+  for (const name of Object.keys(given)) {
+    throw new Error(`Unknown option '${name}' for language 'python'`)
+  }
+
+  return {}
+}
+
+exports.layout = function layout(out) {
+  const name = path.posix.basename(out.pathname).replace(/-/g, '_')
+
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+    throw new Error(`'${name}' is not a valid Python package name`)
+  }
+
+  return {
+    harness: new URL(`${name}/__init__.py`, out),
+    name,
+    manifest: new URL('pyproject.toml', out)
+  }
+}
+
+exports.sibling = function sibling(url, name) {
+  return new URL(`${name}.py`, url)
+}
+
+exports.reference = function reference(from, to) {
+  const relative = path.posix.relative(path.posix.dirname(from.pathname), to.pathname)
+
+  if (relative.endsWith('.py') && !relative.includes('/')) {
+    return '.' + path.posix.basename(relative, '.py')
+  }
+
+  return relative
+}
+
+exports.manifest = function manifest({ name, dependencies, artifacts }) {
+  const requirements = Object.entries(dependencies).map(
+    ([dependency, version]) => `  ${JSON.stringify(dependency + version)},`
+  )
+
+  // The bundle is listed as an artifact so that it is included in the wheel
+  // even when ignored by version control.
+  return `\
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = ${JSON.stringify(name)}
+version = "0.0.0"
+requires-python = ">=3.10"
+dependencies = [
+${requirements.join('\n')}
+]
+
+[tool.hatch.build.targets.wheel]
+packages = [${JSON.stringify(name)}]
+artifacts = [${artifacts.map((artifact) => JSON.stringify(artifact)).join(', ')}]
+`
+}

package/lib/language/swift.js

@@ -0,0 +1,111 @@
+const path = require('path')
+
+exports.name = 'swift'
+
+exports.options = function options(given = {}) {
+  for (const name of Object.keys(given)) {
+    throw new Error(`Unknown option '${name}' for language 'swift'`)
+  }
+
+  return {}
+}
+
+exports.layout = function layout(out) {
+  const name = path.posix.basename(out.pathname).split(/[-_.]/).map(capitalize).join('')
+
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+    throw new Error(`'${name}' is not a valid Swift module name`)
+  }
+
+  return {
+    harness: new URL(`Sources/${name}/Harness.swift`, out),
+    name,
+    manifest: new URL('Package.swift', out),
+    addons: new URL('Frameworks/', out),
+    resources: out
+  }
+}
+
+exports.sibling = function sibling(url, name) {
+  return new URL(capitalize(name) + '.swift', url)
+}
+
+exports.reference = function reference(from, to) {
+  return path.posix.relative(path.posix.dirname(from.pathname), to.pathname)
+}
+
+// The oldest versions of the Apple platforms that the Swift runtimes support.
+const platforms = {
+  darwin: '.macOS(.v13)',
+  ios: '.iOS(.v15)'
+}
+
+// The dependencies of Swift generators map package identities to the URL, the
+// minimum version, and the products of the package that the module uses. Like
+// npm, a minor release of a package before 1.0.0 may break compatibility.
+exports.manifest = function manifest({ name, dependencies, hosts, artifacts, addons = [] }) {
+  const supported = Object.entries(platforms)
+    .filter(([platform]) => hosts.some((host) => host.startsWith(platform + '-')))
+    .map(([, minimum]) => minimum)
+
+  const packages = Object.values(dependencies).map(({ url, from }) => {
+    const version = from.startsWith('0.')
+      ? `.upToNextMinor(from: ${JSON.stringify(from)})`
+      : `from: ${JSON.stringify(from)}`
+
+    return `    .package(url: ${JSON.stringify(url)}, ${version}),`
+  })
+
+  const products = Object.entries(dependencies).flatMap(([identity, { products }]) =>
+    products.map(
+      (product) =>
+        `        .product(name: ${JSON.stringify(product)}, package: ${JSON.stringify(identity)}),`
+    )
+  )
+
+  // Linked addons are binary targets that the module depends on.
+  const frameworks = addons
+    .filter((addon) => addon.endsWith('.xcframework'))
+    .map((addon) => ({ name: path.posix.basename(addon, '.xcframework'), path: addon }))
+
+  for (const framework of frameworks) products.push(`        ${JSON.stringify(framework.name)},`)
+
+  const binaries = frameworks.map(
+    (framework) =>
+      `,\n    .binaryTarget(name: ${JSON.stringify(framework.name)}, path: ${JSON.stringify(framework.path)})`
+  )
+
+  // Resources are named relative to the directory of the module.
+  const resources = artifacts.map(
+    (artifact) => `.copy(${JSON.stringify(path.posix.relative(`Sources/${name}`, artifact))})`
+  )
+
+  return `\
+// swift-tools-version: 5.10
+import PackageDescription
+
+let package = Package(
+  name: ${JSON.stringify(name)},
+  platforms: [${supported.join(', ')}],
+  products: [
+    .library(name: ${JSON.stringify(name)}, targets: [${JSON.stringify(name)}])
+  ],
+  dependencies: [
+${packages.join('\n')}
+  ],
+  targets: [
+    .target(
+      name: ${JSON.stringify(name)},
+      dependencies: [
+${products.join('\n')}
+      ],
+      resources: [${resources.join(', ')}]
+    )${binaries.join('')}
+  ]
+)
+`
+}
+
+function capitalize(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1)
+}

package/lib/language.js

@@ -0,0 +1,18 @@
+const { registry } = require('./provider')
+
+const providers = {
+  javascript: () => require('./language/javascript'),
+  kotlin: () => require('./language/kotlin'),
+  python: () => require('./language/python'),
+  swift: () => require('./language/swift')
+}
+
+module.exports = registry('language', providers, function validate(language) {
+  for (const method of ['options', 'layout', 'sibling', 'reference', 'manifest']) {
+    if (typeof language?.[method] !== 'function') {
+      throw new Error(`Language must provide a ${method}() function`)
+    }
+  }
+
+  return language
+})

package/lib/link.js

@@ -0,0 +1,141 @@
+const pack = require('bare-pack')
+const fs = require('./fs')
+const assets = require('./assets')
+const shim = require('./shim')
+const graph = require('./graph')
+const rpcs = require('./rpc')
+
+module.exports = async function* link(entries, target, out, opts = {}) {
+  if (!target) throw new Error("'target' is required")
+  if (!out) throw new Error("'out' is required")
+
+  let {
+    language,
+    languageOptions,
+    targetOptions,
+    server,
+    hosts,
+    resolveTarget,
+    resolveRPC,
+    resolveLanguage,
+    ...packOpts
+  } = opts
+
+  entries = await Promise.all([].concat(entries).map((entry) => fs.resolveModule(new URL(entry))))
+
+  if (entries.length === 0) throw new Error("'entries' must not be empty")
+  out = new URL(out)
+
+  if (!out.pathname.endsWith('/')) out.pathname += '/'
+
+  const resolved = graph.providers(target, {
+    language,
+    languageOptions,
+    targetOptions,
+    hosts,
+    resolveTarget,
+    resolveLanguage
+  })
+
+  const { harness, options } = resolved
+
+  target = resolved.target
+  language = resolved.language
+  hosts = resolved.hosts
+
+  if (!target.linked) throw new Error(`Target '${target.name}' does not link addons`)
+
+  if (typeof harness.link !== 'function') {
+    throw new Error(
+      `Target '${target.name}' does not support linking for language '${language.name}'`
+    )
+  }
+
+  if (server) server = rpcs(server, resolveRPC)
+
+  const layout = language.layout(out, options)
+
+  if (!layout.addons) throw new Error(`Language '${language.name}' does not support linked addons`)
+
+  // Every shim imports the same runtime and RPC server, so one covers them all.
+  const main = shim(entries[0], target.isolation, server)
+
+  const traversal = graph.traversal(packOpts, hosts)
+  const readModule = graph.readModule(main.modules)
+
+  const addons = []
+
+  for await (const url of graph.link(
+    [main.url, ...entries.slice(1)],
+    layout.addons,
+    traversal,
+    readModule
+  )) {
+    addons.push(url)
+    yield { url }
+  }
+
+  const linked = await collectAssets(entries, traversal, readModule)
+
+  if (linked.length > 0) {
+    if (!layout.resources) {
+      throw new Error(`Language '${language.name}' does not support linked assets`)
+    }
+
+    for await (const url of assets.write(layout.resources, assets.app, linked)) yield { url }
+  }
+
+  const generated = harness.link({ options })
+
+  const files = []
+
+  if (generated.source) files.push({ url: layout.harness, source: generated.source })
+
+  files.push({
+    url: layout.manifest,
+    source: language.manifest({
+      name: layout.name,
+      dependencies: generated.dependencies || {},
+      options,
+      hosts,
+      artifacts: [],
+      addons: addons.map((url) => language.reference(layout.manifest, url))
+    })
+  })
+
+  for (const file of files) {
+    await fs.writeFile(file.url, file.source)
+    yield { url: file.url }
+  }
+}
+
+async function collectAssets(entries, traversal, readModule) {
+  const collected = new Map()
+
+  for (const entry of entries) {
+    const bundle = await pack(
+      entry,
+      { ...traversal, linked: true },
+      readModule,
+      fs.listPrefix,
+      fs.resolveModule
+    )
+
+    for (const key of bundle.assets) {
+      const url = new URL(key)
+      const relative = await assets.path(url)
+      const source = bundle.read(key)
+      const existing = collected.get(relative)
+
+      if (existing && !existing.source.equals(source)) {
+        throw new Error(
+          `Assets '${existing.url.href}' and '${url.href}' both link as '${relative}'`
+        )
+      }
+
+      collected.set(relative, { path: relative, url, source })
+    }
+  }
+
+  return [...collected.values()]
+}

package/lib/provider.js

@@ -0,0 +1,33 @@
+exports.registry = function registry(kind, providers, validate) {
+  return function provider(name, resolve) {
+    if (typeof name !== 'string') return validate(name)
+
+    const load = providers[name]
+
+    if (load) return load()
+
+    if (resolve) return validate(resolve(name))
+
+    throw new Error(`Unknown ${kind} '${name}'`)
+  }
+}
+
+exports.validateLanguages = function validateLanguages(kind, languages) {
+  if (typeof languages !== 'object' || languages === null) {
+    throw new Error(`${kind} must provide a languages object`)
+  }
+
+  for (const [name, entry] of Object.entries(languages)) {
+    if (!entry || typeof entry.generate !== 'function') {
+      throw new Error(`${kind} must provide a generate() function for language '${name}'`)
+    }
+  }
+}
+
+exports.select = function select(kind, provider, language) {
+  if (!Object.hasOwn(provider.languages, language)) {
+    throw new Error(`${kind} '${provider.name}' does not support language '${language}'`)
+  }
+
+  return provider.languages[language]
+}