@apexnative/navigation 0.0.0-stage → 1.0.0-alpha.0

package/cli/codegen/index.js

@@ -0,0 +1,211 @@
+// @ts-check
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { createRun } = require('../changes');
+const { readConfig } = require('../config');
+const { exec } = require('../exec');
+const { createUI } = require('../ui');
+const { openWorkspace } = require('../workspace');
+const { addSourceFile } = require('../xcode/pbxproj');
+const { kotlinFile, PACKAGE } = require('./kotlin');
+const { createProgram, readCommandScreens, readNativeScreens } = require('./read');
+const { swiftFile } = require('./swift');
+
+/** @typedef {import('../changes').FileChange} FileChange */
+
+const SWIFT_FILE = 'ApexNavigation.generated.swift';
+const KOTLIN_FILE = 'ApexNavigationGenerated.kt';
+
+/**
+ * The generated files of the app's native screens, as they should be now: next to AppDelegate.swift (in the Xcode
+ * project too) and in the package the navigation finds on Android. None for an app without native screens, unless
+ * the files are there already (then they are made again, without the screens that went).
+ * @param {string} root
+ * @param {import('../workspace').Workspace} workspace
+ * @param {{ overrides?: Map<string, string>; kinds?: import('../config').Config['nativeScreens'] }} [options]
+ *   `overrides`: files as a command is about to write them (by absolute path), read in place of the disk; `kinds`: the
+ *   native screens' kinds, in place of the settings
+ * @returns {{ changes: FileChange[]; screens: string[]; errors: string[]; skipped?: string[] }} `errors`: types with
+ *   no native form, as `file:line: message`; `skipped`: the screens left out of the typed commands, and why
+ */
+function planCodegen(
+  root,
+  { ts, project, navigation },
+  { overrides = new Map(), kinds: given } = {}
+) {
+  const program = createProgram(ts, root, navigation, overrides);
+  const { screens, errors } = readNativeScreens(ts, program, root);
+  if (errors.length > 0) {
+    return {
+      changes: [],
+      screens: [],
+      errors: errors.map(({ file, line, message }) => `${file}:${line}: ${message}`),
+    };
+  }
+  const names = screens.map(({ nativeName }) => nativeName);
+  const twice = names.filter((name, index) => names.indexOf(name) !== index);
+  if (twice.length > 0) {
+    return {
+      changes: [],
+      screens: [],
+      errors: [...new Set(twice)].map(
+        (name) => `Two native screens are registered as "${name}": a name goes once`
+      ),
+    };
+  }
+  const kinds = given ?? readConfig(root).nativeScreens ?? {};
+  // Every screen of the app, for the typed commands of native code: only with native screens, which have them.
+  const commands =
+    screens.length > 0 ? readCommandScreens(ts, program, navigation) : { screens: [], skipped: [] };
+  const textOf = (/** @type {string} */ file) =>
+    overrides.get(file) ?? (fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : undefined);
+  /** @type {FileChange[]} */
+  const changes = [];
+
+  if (project.appDelegate) {
+    const file = path.join(path.dirname(project.appDelegate), SWIFT_FILE);
+    if (screens.length > 0 || fs.existsSync(file)) {
+      changes.push(
+        generated(
+          file,
+          textOf(file),
+          'ios',
+          swiftFile(
+            screens.map((screen) => ({ screen, kind: kinds[screen.nativeName]?.ios })),
+            commands.screens
+          )
+        )
+      );
+      const xcodeText = project.xcodeProject && textOf(project.xcodeProject);
+      if (project.xcodeProject && xcodeText !== undefined) {
+        changes.push(xcodeChange(project.xcodeProject, xcodeText, project.appDelegate, file));
+      }
+    }
+  }
+  if (project.androidSources && project.androidPackage) {
+    const file = path.join(project.androidSources, ...PACKAGE.split('.'), KOTLIN_FILE);
+    if (screens.length > 0 || fs.existsSync(file)) {
+      const text = kotlinFile(
+        screens.map((screen) => ({ screen, kind: kinds[screen.nativeName]?.android })),
+        { appPackage: project.androidPackage, commands: commands.screens }
+      );
+      changes.push(generated(file, textOf(file), 'android', text));
+    }
+  }
+  return {
+    changes,
+    screens: names,
+    errors: [],
+    skipped: commands.skipped.map(
+      ({ name, reason }) =>
+        `${name} has no typed command, native code opens it by its name: ${reason}`
+    ),
+  };
+}
+
+/**
+ * A generated file: made again whole each time.
+ * @param {string} file
+ * @param {string | undefined} before its text now; none when it isn't there
+ * @param {string} platform
+ * @param {string} next
+ * @returns {FileChange}
+ */
+function generated(file, before, platform, next) {
+  const name = path.basename(file);
+  if (before === undefined) {
+    return { name, platform, file, status: 'create', next, note: 'generated' };
+  }
+  if (before === next) return { name, platform, file, status: 'done', note: 'up to date' };
+  return { name, platform, file, status: 'change', before, next, note: 'generated again' };
+}
+
+/**
+ * The generated Swift file in the app's target, next to AppDelegate.swift.
+ * @param {string} xcodeProject
+ * @param {string} before the project's text now
+ * @param {string} appDelegate
+ * @param {string} file
+ * @returns {FileChange}
+ */
+function xcodeChange(xcodeProject, before, appDelegate, file) {
+  const result = addSourceFile(before, {
+    anchor: 'AppDelegate.swift',
+    anchorFile: appDelegate,
+    file,
+  });
+  const name = 'project.pbxproj';
+  if (result.status === 'done')
+    return {
+      name,
+      platform: 'ios',
+      file: xcodeProject,
+      status: 'done',
+      note: `${SWIFT_FILE} in the target`,
+    };
+  if (result.status === 'manual') {
+    return {
+      name,
+      platform: 'ios',
+      file: xcodeProject,
+      status: 'manual',
+      note: `${result.reason}, see below`,
+      howTo: `In Xcode, add ${path.relative(path.dirname(path.dirname(xcodeProject)), file)} to the app's target.`,
+    };
+  }
+  return {
+    name,
+    platform: 'ios',
+    file: xcodeProject,
+    status: 'change',
+    before,
+    next: result.next,
+    note: `+ ${SWIFT_FILE}`,
+  };
+}
+
+/**
+ * Generates the native side of the app's native screens from their props in TypeScript.
+ * @param {{
+ *   root: string;
+ *   yes: boolean;
+ *   dryRun: boolean;
+ *   json?: boolean;
+ *   ui?: ReturnType<typeof createUI>;
+ *   run?: import('../exec').Exec;
+ *   header?: boolean;
+ * }} options `header: false` leaves the banner out, as when doctor runs codegen to fix what it found
+ * @returns {Promise<number>} the exit code
+ */
+async function codegen({
+  root,
+  yes,
+  dryRun,
+  json = false,
+  ui = createUI(),
+  run = exec,
+  header = true,
+}) {
+  const command = createRun({ command: 'codegen', root, json, ui });
+  if (header && !json) ui.banner({ command: 'codegen', facts: [{ text: 'Swift · Kotlin' }] });
+  const workspace = openWorkspace(root, run);
+  if ('code' in workspace) return command.fail(workspace.code, workspace.message);
+  const { changes, screens, errors, skipped = [] } = planCodegen(root, workspace);
+  if (errors.length > 0) return command.fail('codegen-types', errors);
+  for (const message of skipped) command.warn(message);
+  if (changes.length === 0) {
+    if (json) return command.apply([], { yes, dryRun });
+    ui.done('The app has no native screens: nothing to generate.');
+    return 0;
+  }
+  return command.apply(changes, {
+    yes,
+    dryRun,
+    done: `Generated for ${screens.length} native ${screens.length === 1 ? 'screen' : 'screens'}`,
+    nothingToDo: 'Up to date.',
+  });
+}
+
+module.exports = { codegen, planCodegen };

package/cli/codegen/kotlin.js

@@ -0,0 +1,396 @@
+// @ts-check
+'use strict';
+
+const { kotlinCommands } = require('./commands');
+const { constantName, kotlinIdentifier, kotlinString, memberName } = require('./names');
+
+/** @typedef {import('./read').Model} Model */
+/** @typedef {import('./read').Field} Field */
+/** @typedef {import('./read').NativeScreenModel} NativeScreenModel */
+/** @typedef {import('../config').AndroidKind} AndroidKind */
+
+/** The package of the generated file: the navigation finds the list of screens in it by name. */
+const PACKAGE = 'dev.apexnative.navigation.generated';
+
+const HEADER = `// Generated by \`npx apex-navigation codegen\` from the native screens of the app. Don't edit it: change the props in
+// TypeScript and run the command again.`;
+
+/**
+ * The Kotlin file of the app's native screens: their props, the screen and navigation types their views take, and the
+ * list the navigation registers as it starts. A screen with a `kind` is registered: its composable (Compose) or class
+ * (Android views) is `<Name>Screen` in the package `<app package>.screens`.
+ * @param {{ screen: NativeScreenModel; kind?: AndroidKind }[]} screens
+ * @param {{ appPackage: string; commands?: import('./read').CommandScreenModel[] }} options `commands`: the
+ *   screens of `screens` for the typed commands, which come after the rest
+ * @returns {string}
+ */
+function kotlinFile(screens, { appPackage, commands = [] }) {
+  const compose = screens.some(({ kind }) => kind === 'compose');
+  const imports = [
+    ...(compose
+      ? [
+          'androidx.compose.runtime.getValue',
+          'androidx.compose.runtime.mutableStateOf',
+          'androidx.compose.runtime.setValue',
+          'androidx.compose.ui.platform.ComposeView',
+        ]
+      : []),
+    'dev.apexnative.navigation.NavigationApplication',
+    'dev.apexnative.navigation.nativescreen.NativeScreenContext',
+    'kotlin.coroutines.resume',
+    'kotlin.coroutines.resumeWithException',
+    'kotlinx.coroutines.suspendCancellableCoroutine',
+    'org.json.JSONArray',
+    'org.json.JSONObject',
+  ];
+  return [
+    HEADER,
+    '',
+    `package ${PACKAGE}`,
+    '',
+    imports.map((name) => `import ${name}`).join('\n'),
+    '',
+    registry(screens, appPackage),
+    ...screens.map(({ screen }) => props(screen)),
+    shared(compose),
+    ...(commands.length > 0 ? [kotlinCommands(commands)] : []),
+  ].join('\n');
+}
+
+/**
+ * @param {{ screen: NativeScreenModel; kind?: AndroidKind }[]} screens
+ * @param {string} appPackage
+ */
+function registry(screens, appPackage) {
+  const registered = screens.flatMap(({ screen, kind }) => {
+    if (!kind) return [];
+    const name = screen.nativeName;
+    const view = `${appPackage}.screens.${name}Screen`;
+    const value = `NativeScreen(context, ::${name}Props)`;
+    return [
+      `    application.registerNativeScreen(${kotlinString(name)}) { activity, context ->`,
+      ...(kind === 'compose'
+        ? [`      ComposeView(activity).apply { setContent { ${view}(${value}) } }`]
+        : [`      ${view}(activity, ${value}).view`]),
+      '    }',
+    ];
+  });
+  return `/** The native screens of the app, which the navigation registers itself as it starts. */
+object ApexNavigationGeneratedScreens {
+  @JvmStatic
+  fun register(application: NavigationApplication) {
+${registered.length > 0 ? registered.join('\n') : '    // None: `npx apex-navigation screen <Name> --native` adds one.'}
+  }
+}
+`;
+}
+
+/**
+ * The props of one screen: a data class with its enums and objects inside, read from the screen's context.
+ * @param {NativeScreenModel} screen
+ */
+function props(screen) {
+  const name = `${screen.nativeName}Props`;
+  const parameters = screen.fields.flatMap((field) => [
+    ...docLines(field.doc, '  '),
+    `  val ${kotlinIdentifier(field.name)}: ${declaredType(field)},`,
+  ]);
+  const reads = screen.fields.map(
+    (field) =>
+      `    ${kotlinIdentifier(field.name)} = ${
+        field.type.kind !== 'function'
+          ? read(field, `context.props.opt(${kotlinString(field.name)})`)
+          : field.optional
+            ? `if (${kotlinString(field.name)} in context.functions) (${call(field.name, field.type)}) else null`
+            : call(field.name, field.type)
+      },`
+  );
+  const enums = screen.enums.map(
+    (item) => `  enum class ${item.name}(val value: String) {
+${item.values.map((value) => `    ${constantName(value)}(${kotlinString(value)}),`).join('\n')}
+  }
+`
+  );
+  const objects = screen.objects.map((object) => {
+    const fields = object.fields.map(
+      (field) => `    val ${kotlinIdentifier(field.name)}: ${declaredType(field)},`
+    );
+    const objectReads = object.fields.map(
+      (field) =>
+        `        ${kotlinIdentifier(field.name)} = ${read(field, `fields.opt(${kotlinString(field.name)})`)},`
+    );
+    const json = object.fields.map(
+      (field) =>
+        `.put(${kotlinString(field.name)}, ${encode(field.type, kotlinIdentifier(field.name), field.optional)})`
+    );
+    return `  data class ${object.name}(
+${fields.join('\n')}
+  ) {
+    fun json(): JSONObject = JSONObject()${json.join('')}
+
+    companion object {
+      fun read(value: Any?): ${object.name} {
+        val fields = Decode.obj(value)
+        return ${object.name}(
+${objectReads.join('\n')}
+        )
+      }
+    }
+  }
+`;
+  });
+  const nested = [...enums, ...objects];
+  return `/** The props of the native screen \`${screen.nativeName}\` (${screen.file}). */
+data class ${name}(
+${parameters.join('\n')}
+) {
+  constructor(context: NativeScreenContext) : this(
+${reads.join('\n')}
+  )
+${nested.length > 0 ? '\n' + nested.join('\n') : ''}}
+`;
+}
+
+/**
+ * @param {Field} field
+ */
+function declaredType(field) {
+  const type = kotlinType(field.type);
+  if (!field.optional) return type;
+  return field.type.kind === 'function' ? `(${type})?` : `${type}?`;
+}
+
+/**
+ * @param {Model} model
+ * @returns {string}
+ */
+function kotlinType(model) {
+  switch (model.kind) {
+    case 'string':
+      return 'String';
+    case 'number':
+      return model.int ? 'Int' : 'Double';
+    case 'boolean':
+      return 'Boolean';
+    case 'enum':
+    case 'object':
+      return model.name;
+    case 'array':
+      return `List<${kotlinType(model.element)}>`;
+    case 'function':
+      return `suspend (${model.parameters.map(({ type }) => kotlinType(type)).join(', ')}) -> ${
+        model.result ? kotlinType(model.result) : 'Unit'
+      }`;
+  }
+}
+
+/**
+ * The expression that reads a field from a value of JS.
+ * @param {Field} field
+ * @param {string} value
+ */
+function read(field, value) {
+  return field.optional
+    ? `if (Decode.present(${value})) ${decode(field.type, value)} else null`
+    : decode(field.type, value);
+}
+
+/**
+ * @param {Model} model
+ * @param {string} value
+ * @returns {string}
+ */
+function decode(model, value) {
+  switch (model.kind) {
+    case 'string':
+      return `Decode.string(${value})`;
+    case 'number':
+      return model.int ? `Decode.int(${value})` : `Decode.number(${value})`;
+    case 'boolean':
+      return `Decode.bool(${value})`;
+    case 'enum':
+      return `Decode.string(${value}).let { raw -> ${model.name}.entries.firstOrNull { it.value == raw } ?: ${model.name}.entries[0] }`;
+    case 'object':
+      return `${model.name}.read(${value})`;
+    case 'array':
+      return `Decode.list(${value}) { ${decode(model.element, 'it')} }`;
+    case 'function':
+      return 'null';
+  }
+}
+
+/**
+ * The value JS gets for a value of Kotlin: an argument of a function, or a field of an object.
+ * @param {Model} model
+ * @param {string} value
+ * @param {boolean} [optional]
+ * @returns {string}
+ */
+function encode(model, value, optional = false) {
+  if (optional) return `(${value}?.let { ${encode(model, 'it')} } ?: JSONObject.NULL)`;
+  switch (model.kind) {
+    case 'enum':
+      return `${value}.value`;
+    case 'object':
+      return `${value}.json()`;
+    case 'array':
+      return `JSONArray(${value}.map { ${encode(model.element, 'it')} })`;
+    default:
+      return value;
+  }
+}
+
+/**
+ * A function of the props: a lambda that calls it in JS with its arguments and reads what it resolved with.
+ * @param {string} name
+ * @param {Extract<Model, { kind: 'function' }>} model
+ */
+function call(name, model) {
+  const parameters = model.parameters.map(({ name: parameter }) =>
+    kotlinIdentifier(memberName(parameter))
+  );
+  const head = parameters.length > 0 ? `${parameters.join(', ')} -> ` : '';
+  const args = model.parameters
+    .map(({ type }, index) => `, ${encode(type, parameters[index])}`)
+    .join('');
+  const called = `context.callJs(${kotlinString(name)}${args})`;
+  const body = model.result ? decode(model.result, called) : `${called}; Unit`;
+  return `{ ${head}${body} }`;
+}
+
+/**
+ * @param {string | undefined} doc
+ * @param {string} indent
+ */
+function docLines(doc, indent) {
+  return doc ? [`${indent}/** ${doc.replace(/\n/g, ' ')} */`] : [];
+}
+
+/**
+ * The screen and navigation types, and the helpers that read plain data from JS.
+ * @param {boolean} compose the props of a Compose screen are state that composes it again
+ */
+function shared(compose) {
+  const propsDeclaration = compose
+    ? `  /** The props as they are now; a composable that reads them composes again when they change. */
+  var props: Props by mutableStateOf(decode(context))
+    private set`
+    : `  /** The props as they are now; [onChange] tells when they change. */
+  var props: Props = decode(context)
+    private set`;
+  return `/** What a native screen gets: its props, which it shows again when they change, and the navigation from it. */
+class NativeScreen<Props>(val context: NativeScreenContext, private val decode: (NativeScreenContext) -> Props) {
+${propsDeclaration}
+
+  /** The commands of the navigation from this screen. */
+  val navigation = ScreenNavigation(context)
+
+  private val listeners = mutableListOf<(Props) -> Unit>()
+
+  init {
+    context.onPropsChange = {
+      props = decode(context)
+      listeners.forEach { listener -> listener(props) }
+    }
+  }
+
+  /** Called on the main thread with the new props, each time they change. */
+  fun onChange(listener: (Props) -> Unit) {
+    listeners += listener
+  }
+}
+
+/** The commands of the navigation from a native screen. They run in JS, as \`useNavigation()\` of a React screen does. */
+class ScreenNavigation(private val context: NativeScreenContext) {
+  /** Shows a screen over this one in its stack; returns the id of the screen shown. */
+  suspend fun push(screen: String, props: Map<String, Any?> = emptyMap()): String =
+    context.navigateJs("push", screen, JSONObject().put("props", JSONObject(props))) as? String ?: ""
+
+  /** Shows a screen over everything, in a stack of its own. */
+  suspend fun showModal(screen: String, props: Map<String, Any?> = emptyMap()): String =
+    context.navigateJs("showModal", screen, JSONObject().put("props", JSONObject(props))) as? String ?: ""
+
+  /** Shows a screen over everything, without taking the place of any. */
+  suspend fun showOverlay(screen: String, props: Map<String, Any?> = emptyMap()): String =
+    context.navigateJs("showOverlay", screen, JSONObject().put("props", JSONObject(props))) as? String ?: ""
+
+  /** Shows a screen in a column of the split view this screen is in. */
+  suspend fun showInColumn(screen: String, props: Map<String, Any?> = emptyMap()): String =
+    context.navigateJs("showInColumn", screen, JSONObject().put("props", JSONObject(props))) as? String ?: ""
+
+  /** Goes back to the screen before this one in its stack. */
+  suspend fun pop() {
+    context.navigateJs("pop")
+  }
+
+  /** Goes back to a screen of this stack, by its id. */
+  suspend fun popTo(screenId: String) {
+    context.navigateJs("popTo", screenId)
+  }
+
+  /** Goes back to the first screen of this stack. */
+  suspend fun popToRoot() {
+    context.navigateJs("popToRoot")
+  }
+
+  /** Closes the modal or the overlay this screen is in. */
+  suspend fun dismiss() {
+    context.navigateJs("dismiss")
+  }
+
+  /** Changes the options of this screen. */
+  suspend fun setOptions(options: Map<String, Any?>) {
+    context.navigateJs("setOptions", JSONObject(options))
+  }
+
+  /** Selects a tab of the tabs this screen is in, by its index. */
+  suspend fun selectTab(index: Int) {
+    context.navigateJs("selectTab", index)
+  }
+
+  /** Selects a tab of the tabs this screen is in, by its id. */
+  suspend fun selectTab(id: String) {
+    context.navigateJs("selectTab", id)
+  }
+
+  /** The badge of this screen's tab; null takes it away. */
+  suspend fun setTabBadge(badge: String?) {
+    context.navigateJs("setTabBadge", badge)
+  }
+}
+
+private suspend fun NativeScreenContext.callJs(function: String, vararg arguments: Any?): Any? =
+  suspendCancellableCoroutine { continuation ->
+    call(function, JSONArray(arguments.toList())) { result ->
+      result.fold({ continuation.resume(it) }, { continuation.resumeWithException(it) })
+    }
+  }
+
+private suspend fun NativeScreenContext.navigateJs(command: String, vararg arguments: Any?): Any? =
+  suspendCancellableCoroutine { continuation ->
+    navigate(command, JSONArray(arguments.toList())) { result ->
+      result.fold({ continuation.resume(it) }, { continuation.resumeWithException(it) })
+    }
+  }
+
+/** Plain data from JS. */
+private object Decode {
+  fun present(value: Any?) = value != null && value != JSONObject.NULL
+
+  fun string(value: Any?) = value as? String ?: ""
+
+  fun number(value: Any?) = (value as? Number)?.toDouble() ?: 0.0
+
+  fun int(value: Any?) = (value as? Number)?.toInt() ?: 0
+
+  fun bool(value: Any?) = value as? Boolean ?: false
+
+  fun obj(value: Any?) = value as? JSONObject ?: JSONObject()
+
+  fun <T> list(value: Any?, item: (Any?) -> T): List<T> =
+    (value as? JSONArray)?.let { array -> (0 until array.length()).map { item(array.opt(it)) } } ?: emptyList()
+}
+`;
+}
+
+module.exports = { kotlinFile, PACKAGE };

package/cli/codegen/names.js

@@ -0,0 +1,99 @@
+// @ts-check
+'use strict';
+
+// Words a name can't be as it is: Swift and Kotlin take them in backticks.
+const SWIFT_KEYWORDS = new Set(
+  (
+    'associatedtype class deinit enum extension fileprivate func import init inout internal let open operator private ' +
+    'precedencegroup protocol public rethrows static struct subscript typealias var break case catch continue default ' +
+    'defer do else fallthrough for guard if in repeat return throw switch where while as false is nil self Self super ' +
+    'throws true try Any Type'
+  ).split(' ')
+);
+const KOTLIN_KEYWORDS = new Set(
+  (
+    'as break class continue do else false for fun if in interface is null object package return super this throw ' +
+    'true try typealias typeof val var when while'
+  ).split(' ')
+);
+
+/**
+ * A name as a type is written: `user` → `User`, `sign-in` → `SignIn`.
+ * @param {string} text
+ */
+function typeName(text) {
+  const name = words(text)
+    .map((word) => word[0].toUpperCase() + word.slice(1))
+    .join('');
+  // A name of Swift and Kotlin doesn't start with a digit.
+  return /^[0-9]/.test(name) ? `_${name}` : name;
+}
+
+/**
+ * A name as a property or a case is written: `sign-in` → `signIn`, `Large Title` → `largeTitle`.
+ * @param {string} text
+ */
+function memberName(text) {
+  const name = typeName(text);
+  return name.startsWith('_') ? name : name[0].toLowerCase() + name.slice(1);
+}
+
+/**
+ * A name in UPPER_SNAKE_CASE, as Kotlin writes enum constants.
+ * @param {string} text
+ */
+function constantName(text) {
+  const name = words(text)
+    .flatMap((word) => word.split(/(?<=[a-z0-9])(?=[A-Z])/))
+    .map((word) => word.toUpperCase())
+    .join('_');
+  return /^[0-9]/.test(name) ? `_${name}` : name;
+}
+
+/** @param {string} text */
+function words(text) {
+  const found = text.split(/[^A-Za-z0-9]+/).filter(Boolean);
+  return found.length > 0 ? found : ['value'];
+}
+
+/**
+ * A name Swift takes as it is, or in backticks.
+ * @param {string} name
+ */
+function swiftIdentifier(name) {
+  return SWIFT_KEYWORDS.has(name) ? `\`${name}\`` : name;
+}
+
+/**
+ * A name Kotlin takes as it is, or in backticks.
+ * @param {string} name
+ */
+function kotlinIdentifier(name) {
+  return KOTLIN_KEYWORDS.has(name) ? `\`${name}\`` : name;
+}
+
+/**
+ * A string literal for Swift source.
+ * @param {string} text
+ */
+function swiftString(text) {
+  return JSON.stringify(text).replace(/\\u([0-9a-f]{4})/gi, '\\u{$1}');
+}
+
+/**
+ * A string literal for Kotlin source, where `$` starts a template.
+ * @param {string} text
+ */
+function kotlinString(text) {
+  return JSON.stringify(text).replace(/\$/g, '\\$');
+}
+
+module.exports = {
+  typeName,
+  memberName,
+  constantName,
+  swiftIdentifier,
+  kotlinIdentifier,
+  swiftString,
+  kotlinString,
+};