ink-framework 0.0.0-stage → 0.1.0-alpha.1

package/src/renderer.ts

@@ -0,0 +1,341 @@
+declare const process: { env: { NODE_ENV: string } };
+import { createContext, type ReactNode } from "./react";
+import Reconciler from "react-reconciler";
+import { ConcurrentRoot, DefaultEventPriority, DiscreteEventPriority } from "react-reconciler/constants";
+import { onNativeMessage } from "./native";
+import { pressHandler } from "./press";
+import type { Destination } from "./navigation";
+import { listPatch, type NativeListItem } from "./list-patch";
+
+declare const __inkCommit: (operations: Operation[]) => void;
+declare const __inkPost: (message: string) => void;
+
+type Props = Record<string, unknown>;
+type Instance = { id: number; type: string; props: Props; children: Instance[]; hidden?: boolean };
+type Container = { id: number; children: Instance[] };
+type Operation =
+  | { op: "create"; id: number; type: string; props: Props }
+  | { op: "update"; id: number; props: Props }
+  | { op: "text"; changes: (number | string)[] }
+  | { op: "insert"; id: number; parent: number; before: number | null }
+  | { op: "remove"; id: number; parent: number }
+  | { op: "hidden"; id: number; value: boolean };
+
+const mounted = new Map<number, Instance>();
+let nextId = 1;
+let operations: Operation[] = [];
+let textChanges: (number | string)[] | undefined;
+let commitScheduled = false;
+let priority = DefaultEventPriority;
+const hostContext = {};
+
+function allocateHostId() {
+  if (!Number.isSafeInteger(nextId)) throw new RangeError("Host identifiers exhausted");
+  return nextId++;
+}
+
+function queue(operation: Operation, preserveTextBatch = false) {
+  if (!preserveTextBatch) textChanges = undefined;
+  operations.push(operation);
+}
+
+function createTextBatch() {
+  const changes: (number | string)[] = [];
+  operations.push({ op: "text", changes });
+  return textChanges = changes;
+}
+
+function textContent(type: string, props: Props): string | null {
+  if (type !== "Text") return null;
+  const value = props.children;
+  return typeof value === "string" ? value : typeof value === "number" || typeof value === "bigint" ? String(value) : null;
+}
+
+function hostProps(type: string, props: Props): Props {
+  if (type !== "Text" || props.href === undefined && props.url === undefined) return props;
+  const { href, url, onPress, ...rest } = props;
+  return { ...rest, onPress: pressHandler({ href: href as Destination | undefined, url: url as string | undefined, onPress: onPress as (() => void) | undefined }) };
+}
+
+function nativeValue(value: unknown): unknown {
+  return typeof value === "function" ? true : value;
+}
+
+function nativeProps(props: Props, type: string): Props {
+  const result: Props = {};
+  for (const name of Object.keys(props)) {
+    if (name === "children" || name === "ref") continue;
+    const value = props[name];
+    if (value === undefined) continue;
+    result[name] = typeof value === "function" ? true : value;
+  }
+  const text = textContent(type, props);
+  if (text !== null) result.text = text;
+  return result;
+}
+
+function publish(instance: Instance) {
+  if (mounted.has(instance.id)) return;
+  mounted.set(instance.id, instance);
+  queue({ op: "create", id: instance.id, type: instance.type, props: nativeProps(instance.props, instance.type) });
+  if (instance.hidden) queue({ op: "hidden", id: instance.id, value: true });
+  for (const child of instance.children) {
+    publish(child);
+    queue({ op: "insert", id: child.id, parent: instance.id, before: null });
+  }
+}
+
+function insert(parent: Container, child: Instance, before?: Instance) {
+  const previous = parent.children.indexOf(child);
+  if (previous !== -1) parent.children.splice(previous, 1);
+  const index = before ? parent.children.indexOf(before) : parent.children.length;
+  parent.children.splice(index, 0, child);
+  publish(child);
+  queue({ op: "insert", id: child.id, parent: parent.id, before: before?.id ?? null });
+}
+
+function forget(instance: Instance) {
+  mounted.delete(instance.id);
+  for (const child of instance.children) forget(child);
+}
+
+function remove(parent: Container, child: Instance) {
+  parent.children.splice(parent.children.indexOf(child), 1);
+  queue({ op: "remove", id: child.id, parent: parent.id });
+  forget(child);
+}
+
+function sameListValue(a: unknown, b: unknown): boolean {
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a)) return Array.isArray(b) && a.length === b.length && a.every((value, index) => sameListValue(value, b[index]));
+  if (Array.isArray(b)) return false;
+  const previous = a as Props, next = b as Props;
+  const keys = Object.keys(previous);
+  return keys.length === Object.keys(next).length && keys.every(key => Object.hasOwn(next, key) && sameListValue(previous[key], next[key]));
+}
+
+function compiledListUpdate(previous: Props, props: Props): Props | null {
+  type Item = NativeListItem;
+  const before = previous.items as Item[], after = props.items as Item[];
+  const patch = listPatch(before, after);
+  let byKey: Map<string, Item> | undefined;
+  let reordered = patch ? patch.keys !== undefined : before.length !== after.length;
+  const changes = patch?.changes ?? [];
+  for (let index = 0; !patch && before !== after && index < after.length; index++) {
+    const item = after[index];
+    let old: Item | undefined = before[index];
+    if (old?.key !== item.key) {
+      reordered = true;
+      byKey ??= new Map(before.map(item => [item.key, item]));
+      old = byKey.get(item.key);
+    }
+    if (!old || !sameListValue(old.measurementKey, item.measurementKey) || !sameListValue(old.values, item.values)) changes.push(item);
+  }
+  const next = nativeProps(props, "NativeList");
+  delete next.items;
+  delete next.template;
+  const metadataChanged = Object.keys({ ...previous, ...props }).some(name =>
+    name !== "items" && name !== "template" && !Object.is(nativeValue(previous[name]), nativeValue(props[name])));
+  if (!changes.length && !reordered && !metadataChanged) return null;
+  next.itemChanges = changes;
+  if (reordered) next.itemKeys = patch?.keys ?? after.map(item => item.key);
+  return next;
+}
+
+function update(instance: Instance, type: string, _oldProps: Props, props: Props) {
+  const previous = instance.props;
+  const isText = type === "Text";
+  if (isText) props = hostProps(type, props);
+  instance.props = props;
+  if (type === "NativeList" && props.keyField === "key" && previous.template === props.template) {
+    const next = compiledListUpdate(previous, props);
+    if (next) queue({ op: "update", id: instance.id, props: next }, true);
+    return;
+  }
+  if (isText) {
+    if (previous.size !== props.size || previous.width !== props.width
+      || previous.align !== props.align || previous.maxLines !== props.maxLines
+      || previous.tabularNumbers !== props.tabularNumbers
+      || (previous.onPress !== props.onPress && nativeValue(previous.onPress) !== nativeValue(props.onPress))) {
+      queue({ op: "update", id: instance.id, props: nativeProps(props, type) });
+      return;
+    }
+    const children = props.children;
+    if (children !== previous.children) {
+      if (typeof children === "string") return (textChanges ?? createTextBatch()).push(instance.id, children);
+      if (typeof children === "number" || typeof children === "bigint") return (textChanges ?? createTextBatch()).push(instance.id, String(children));
+    }
+    return;
+  }
+  let previousCount = 0;
+  let changed = false;
+  for (const name of Object.keys(previous)) {
+    if (name === "children" || name === "ref") continue;
+    const value = previous[name];
+    if (value === undefined) continue;
+    previousCount++;
+    const next = props[name];
+    if (!Object.is(
+      typeof value === "function" ? true : value,
+      typeof next === "function" ? true : next,
+    ) || !Object.hasOwn(props, name)) {
+      changed = true;
+      break;
+    }
+  }
+  if (!changed) {
+    let nextCount = 0;
+    for (const name of Object.keys(props)) {
+      if (name !== "children" && name !== "ref" && props[name] !== undefined) nextCount++;
+    }
+    if (previousCount === nextCount) return;
+  }
+  const next = nativeProps(props, type);
+  if (type === "List" && nativeValue(previous.revision) === next.revision
+    && nativeValue(previous.keys) === next.keys && nativeValue(previous.contentVersions) === next.contentVersions) {
+    delete next.keys;
+    delete next.contentVersions;
+  }
+  // Other node props cannot overwrite a pending text value.
+  queue({ op: "update", id: instance.id, props: next }, type !== "#text");
+}
+
+function hide(instance: Instance, value: boolean) {
+  instance.hidden = value;
+  if (mounted.has(instance.id)) queue({ op: "hidden", id: instance.id, value });
+}
+
+function errorMessage(error: unknown, info: { componentStack?: string | null }) {
+  const message = error instanceof Error ? `${error.name}: ${error.message}\n${error.stack ?? ""}` : String(error);
+  return info.componentStack ? `${message}\n${info.componentStack}` : message;
+}
+
+function report(error: unknown, info: { componentStack?: string | null }) {
+  __inkPost(JSON.stringify({ type: "error", message: errorMessage(error, info) }));
+}
+
+function reportRecovered(error: unknown, info: { componentStack?: string | null }) {
+  __inkPost(JSON.stringify({ type: "log", level: "error", message: errorMessage(error, info) }));
+}
+
+const reconciler = Reconciler<string, Props, Container, Instance, Instance, never, never, never,
+  Instance, object, never, ReturnType<typeof setTimeout>, -1, null>({
+  supportsMutation: true,
+  supportsPersistence: false,
+  supportsHydration: false,
+  isPrimaryRenderer: true,
+  supportsMicrotasks: true,
+  createInstance: (type, props) => ({ id: allocateHostId(), type, props: hostProps(type, props), children: [] }),
+  createTextInstance: text => ({ id: allocateHostId(), type: "#text", props: { text }, children: [] }),
+  appendInitialChild: (parent, child) => { parent.children.push(child); },
+  finalizeInitialChildren: () => false,
+  shouldSetTextContent: (type, props) => {
+    if (type !== "Text") return false;
+    const kind = typeof props.children;
+    return kind === "string" || kind === "number" || kind === "bigint";
+  },
+  getRootHostContext: () => hostContext,
+  getChildHostContext: () => hostContext,
+  getPublicInstance: instance => instance,
+  prepareForCommit: () => null,
+  resetAfterCommit: () => {
+    if (!operations.length || commitScheduled) return;
+    commitScheduled = true;
+    queueMicrotask(() => {
+      // Revealing an Activity reconnects store subscriptions in passive effects.
+      // Include their synchronous corrections before presenting the page.
+      while (reconciler.flushPassiveEffects()) {}
+      reconciler.flushSyncWork();
+      const committed = operations;
+      operations = [];
+      textChanges = undefined;
+      commitScheduled = false;
+      if (committed.length) __inkCommit(committed);
+    });
+  },
+  preparePortalMount: () => {},
+  scheduleTimeout: setTimeout,
+  cancelTimeout: clearTimeout,
+  noTimeout: -1,
+  scheduleMicrotask: queueMicrotask,
+  getInstanceFromNode: () => null,
+  beforeActiveInstanceBlur: () => {},
+  afterActiveInstanceBlur: () => {},
+  prepareScopeUpdate: () => {},
+  getInstanceFromScope: () => null,
+  detachDeletedInstance: () => {},
+  appendChild: insert,
+  appendChildToContainer: insert,
+  insertBefore: insert,
+  insertInContainerBefore: insert,
+  removeChild: remove,
+  removeChildFromContainer: remove,
+  resetTextContent: instance => { (textChanges ?? createTextBatch()).push(instance.id, ""); },
+  commitTextUpdate: (instance, _oldText, text) => {
+    instance.props = { text };
+    (textChanges ?? createTextBatch()).push(instance.id, text);
+  },
+  commitUpdate: update,
+  hideInstance: instance => hide(instance, true),
+  hideTextInstance: instance => hide(instance, true),
+  unhideInstance: instance => hide(instance, false),
+  unhideTextInstance: instance => hide(instance, false),
+  clearContainer: container => {
+    for (const child of [...container.children]) remove(container, child);
+  },
+  NotPendingTransition: null,
+  // React's public Context type omits the fields consumed by its reconciler.
+  HostTransitionContext: createContext(null) as unknown as Reconciler.ReactContext<null>,
+  setCurrentUpdatePriority: value => { priority = value; },
+  getCurrentUpdatePriority: () => priority,
+  resolveUpdatePriority: () => priority,
+  resetFormInstance: () => {},
+  requestPostPaintCallback: callback => { setTimeout(() => callback(performance.now()), 0); },
+  shouldAttemptEagerTransition: () => false,
+  trackSchedulerEvent: () => {},
+  resolveEventType: () => null,
+  resolveEventTimeStamp: () => performance.now(),
+  maySuspendCommit: () => false,
+  preloadInstance: () => true,
+  startSuspendingCommit: () => {},
+  suspendInstance: () => {},
+  waitForCommitToBeReady: () => null,
+});
+
+export function dispatchEvent(id: number, name: string, args: unknown[]) {
+  const handler = mounted.get(id)?.props[name];
+  if (typeof handler !== "function") return;
+  const previous = priority;
+  priority = DiscreteEventPriority;
+  try {
+    handler(...args);
+  } finally {
+    priority = previous;
+  }
+}
+
+let developmentRoot: ReturnType<typeof reconciler.createContainer> | undefined;
+if (process.env.NODE_ENV === "development") {
+  reconciler.injectIntoDevTools({ bundleType: 1, version: "19.2.8", rendererPackageName: "ink" });
+}
+
+export function render(element: ReactNode) {
+  if (process.env.NODE_ENV === "development" && developmentRoot) {
+    const root = developmentRoot;
+    reconciler.updateContainer(element, root, null, null);
+    return () => reconciler.updateContainer(null, root, null, null);
+  }
+  onNativeMessage("event", message => {
+    if (typeof message.id !== "number" || !Number.isSafeInteger(message.id)
+      || typeof message.name !== "string" || !Array.isArray(message.args)) {
+      throw new Error("Invalid native event");
+    }
+    dispatchEvent(message.id, message.name, message.args);
+  });
+  const container: Container = { id: 0, children: [] };
+  const root = reconciler.createContainer(container, ConcurrentRoot, null, false, null, "", report, reportRecovered, reportRecovered, () => {});
+  if (process.env.NODE_ENV === "development") developmentRoot = root;
+  reconciler.updateContainer(element, root, null, null);
+  return () => reconciler.updateContainer(null, root, null, null);
+}

package/src/reorder.ts

@@ -0,0 +1,49 @@
+import { createElement } from "./react";
+import { Button, Stack, Text } from "./index";
+import { keyboardArrowDown, keyboardArrowUp } from "./icons";
+import { List } from "./list";
+import { nativeListRow, nativeListTemplate } from "./native-list";
+
+const template = /* @__PURE__ */ nativeListTemplate((node, field) => node("Stack", { axis: "horizontal", align: "center", justify: "space-between", gap: 12 }, [
+  node("Text", { text: field("label"), maxLines: field("maxLines") }),
+  node("Stack", { axis: "horizontal", align: "center", gap: 4 }, [
+    node("Button", { icon: keyboardArrowDown, disabled: field("last"), onPress: field("down") }),
+    node("Button", { icon: keyboardArrowUp, disabled: field("first"), onPress: field("up") }),
+  ]),
+]));
+
+export type ReorderListProps<T> = {
+  items: readonly T[];
+  keyExtractor: (item: T) => string;
+  getLabel: (item: T) => string;
+  onChange: (items: T[]) => void;
+  multiline?: boolean;
+  gap?: number;
+};
+
+export function ReorderList<T>({ items, keyExtractor, getLabel, onChange, multiline = false, gap }: ReorderListProps<T>) {
+  function move(index: number, direction: -1 | 1) {
+    const target = index + direction;
+    if (target < 0 || target >= items.length) return;
+    const next = [...items];
+    [next[index], next[target]] = [next[target], next[index]];
+    onChange(next);
+  }
+
+  return createElement(List<T>, {
+    items,
+    keyExtractor,
+    gap,
+    measurementKey: multiline ? "multiline" : "single-line",
+    renderItem: nativeListRow((item: T, index: number) => createElement(Stack, {
+      axis: "horizontal", align: "center", justify: "space-between", gap: 12,
+    },
+    createElement(Text, { maxLines: multiline ? undefined : 1 }, getLabel(item)),
+    createElement(Stack, { axis: "horizontal", align: "center", gap: 4 },
+      createElement(Button, { icon: keyboardArrowDown, disabled: index === items.length - 1, onPress: () => move(index, 1) }),
+      createElement(Button, { icon: keyboardArrowUp, disabled: index === 0, onPress: () => move(index, -1) }),
+    )), (item, index) => [{ label: getLabel(item), maxLines: multiline ? undefined : 1,
+      first: index === 0, last: index === items.length - 1,
+      down: () => move(index, 1), up: () => move(index, -1) }], template),
+  });
+}

package/src/resource.ts

@@ -0,0 +1,134 @@
+import type { Snapshot, SnapshotSource } from "./snapshot";
+
+export type ResourceSnapshot<T> =
+  | Exclude<Snapshot<T>, { status: "ready" }>
+  | { status: "ready"; data: T; refreshing: boolean; refreshError: Error | null };
+
+export interface ResourceSource<T> extends SnapshotSource<T> {
+  getSnapshot(): ResourceSnapshot<T>;
+  refresh(): Promise<void>;
+}
+
+type Key = readonly (string | number | boolean | null)[];
+const CACHE_TIME = 300_000;
+const ERROR_BACKOFF = 60_000;
+
+export function resource<Args extends unknown[], T>(options: {
+  key: (...args: Args) => Key;
+  load: (...args: Args) => Promise<T>;
+  staleTime?: number;
+  refreshInterval?: number;
+}): (...args: Args) => ResourceSource<T> {
+  const staleTime = options.staleTime ?? 0;
+  const interval = options.refreshInterval;
+  if (!Number.isFinite(staleTime) || staleTime < 0 ||
+      (interval !== undefined && (!Number.isFinite(interval) || interval <= 0))) {
+    throw new Error("Resource timings must be finite; staleTime must be non-negative and refreshInterval must be positive.");
+  }
+  const entries = new Map<string, ReturnType<typeof createEntry>>();
+
+  function entryFor(key: string, args: Args) {
+    let entry = entries.get(key);
+    if (!entry) {
+      entry = createEntry(key, args);
+      entries.set(key, entry);
+    }
+    return entry;
+  }
+
+  function createEntry(key: string, args: Args) {
+    let state: ResourceSnapshot<T> = { status: "loading" };
+    let pending: Promise<void> | null = null;
+    let updatedAt = 0;
+    let retryAt = 0;
+    let polling: ReturnType<typeof setTimeout> | undefined;
+    let expiry: ReturnType<typeof setTimeout> | undefined;
+    const listeners = new Set<() => void>();
+
+    function publish(next: ResourceSnapshot<T>) {
+      state = next;
+      for (const listener of listeners) listener();
+    }
+
+    function expire() {
+      if (expiry !== undefined) clearTimeout(expiry);
+      expiry = setTimeout(() => {
+        expiry = undefined;
+        if (!listeners.size && !pending) {
+          state = { status: "loading" };
+          entries.delete(key);
+        }
+      }, CACHE_TIME);
+    }
+
+    function schedule() {
+      if (polling !== undefined) clearTimeout(polling);
+      polling = undefined;
+      if (listeners.size && interval !== undefined && state.status === "ready" && !state.refreshError) {
+        polling = setTimeout(() => { void refresh(true); }, Math.max(0, updatedAt + interval - Date.now()));
+      }
+    }
+
+    function refresh(force = false): Promise<void> {
+      if (pending) return pending;
+      if (!force && (Date.now() < retryAt ||
+          (state.status === "ready" && Date.now() < updatedAt + staleTime))) return Promise.resolve();
+      if (polling !== undefined) clearTimeout(polling);
+      polling = undefined;
+      // Establish the pending request before notifying subscribers, which may call refresh.
+      pending = Promise.resolve().then(() => options.load(...args)).then(data => {
+        updatedAt = Date.now();
+        retryAt = 0;
+        publish({ status: "ready", data, refreshing: false, refreshError: null });
+      }).catch(cause => {
+        const error = cause instanceof Error ? cause : new Error(String(cause));
+        retryAt = Date.now() + ERROR_BACKOFF;
+        publish(state.status === "ready"
+          ? { ...state, refreshing: false, refreshError: error }
+          : { status: "error", error });
+      }).finally(() => {
+        pending = null;
+        if (listeners.size) schedule();
+        else expire();
+      });
+      publish(state.status === "ready"
+        ? { ...state, refreshing: true, refreshError: null }
+        : { status: "loading" });
+      return pending;
+    }
+
+    function subscribe(listener: () => void) {
+      if (expiry !== undefined) clearTimeout(expiry);
+      expiry = undefined;
+      listeners.add(listener);
+      void refresh();
+      if (!pending) schedule();
+      return () => {
+        listeners.delete(listener);
+        if (!listeners.size) {
+          if (polling !== undefined) clearTimeout(polling);
+          polling = undefined;
+          expire();
+        }
+      };
+    }
+
+    // Old handles still select the canonical entry after inactive data has expired.
+    const source: ResourceSource<T> = {
+      getSnapshot: () => entryFor(key, args).snapshot(),
+      subscribe: listener => entryFor(key, args).subscribe(listener),
+      refresh: () => entryFor(key, args).refresh(true),
+    };
+    expire();
+    return { source, snapshot: () => state, subscribe, refresh };
+  }
+
+  return (...args) => {
+    const parts = options.key(...args);
+    if (parts.some(part => part !== null && typeof part !== "string" && typeof part !== "boolean" &&
+        (typeof part !== "number" || !Number.isFinite(part)))) {
+      throw new Error("Resource keys must contain only strings, finite numbers, booleans or null.");
+    }
+    return entryFor(JSON.stringify(parts), args).source;
+  };
+}

package/src/route-path.ts

@@ -0,0 +1,38 @@
+export type PathParams<Path extends string> =
+  Path extends `${string}[${infer Name}]${infer Rest}`
+    ? { [Key in Name | keyof PathParams<Rest>]: string }
+    : Record<never, never>;
+
+export function parameterNames(path: string): string[] {
+  return [...path.matchAll(/\[([A-Za-z_][A-Za-z0-9_]*)\]/g)].map(match => match[1]);
+}
+
+export function matchPath(pattern: string, path: string): Record<string, string> | undefined {
+  const expected = pattern.split("/");
+  const actual = path.split("/");
+  if (expected.length !== actual.length) return;
+  const params: Record<string, string> = {};
+  for (let index = 0; index < expected.length; index++) {
+    const name = /^\[([A-Za-z_][A-Za-z0-9_]*)\]$/.exec(expected[index])?.[1];
+    if (name) {
+      if (!actual[index]) return;
+      try {
+        Object.defineProperty(params, name, {
+          value: decodeURIComponent(actual[index]), enumerable: true, writable: true, configurable: true,
+        });
+      } catch { return; }
+    } else if (expected[index] !== actual[index]) return;
+  }
+  return params;
+}
+
+// Compare each segment so a static name wins over a parameter at the same depth.
+export function comparePaths(left: string, right: string): number {
+  const a = left.split("/");
+  const b = right.split("/");
+  for (let index = 0; index < Math.min(a.length, b.length); index++) {
+    const difference = Number(a[index].startsWith("[")) - Number(b[index].startsWith("["));
+    if (difference) return difference;
+  }
+  return left.localeCompare(right);
+}

package/src/scroll.ts

@@ -0,0 +1,3 @@
+import { createContext } from "./react";
+
+export const ScrollToEndContext = /* @__PURE__ */ createContext<(() => void) | undefined>(undefined);

package/src/snapshot.ts

@@ -0,0 +1,18 @@
+import { useSyncExternalStore } from "./react";
+import type { ResourceSnapshot, ResourceSource } from "./resource";
+
+export type Snapshot<T> =
+  | { status: "loading" }
+  | { status: "ready"; data: T }
+  | { status: "error"; error: Error };
+
+export interface SnapshotSource<T> {
+  subscribe(listener: () => void): () => void;
+  getSnapshot(): Snapshot<T>;
+}
+
+export function useSnapshot<T>(source: ResourceSource<T>): ResourceSnapshot<T>;
+export function useSnapshot<T>(source: SnapshotSource<T>): Snapshot<T>;
+export function useSnapshot<T>(source: SnapshotSource<T>): Snapshot<T> {
+  return useSyncExternalStore(source.subscribe, source.getSnapshot, source.getSnapshot);
+}

package/tsconfig.app.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "lib": ["ES2022", "ES2023.Array"],
+    "types": ["ink/runtime-types", "react"]
+  }
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "lib": [
+      "ES2022"
+    ],
+    "types": [
+      "react"
+    ]
+  },
+  "include": [
+    "src",
+    "runtime.d.ts"
+  ]
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.