@nativescript/ios 9.1.0-alpha.18 → 9.1.0-alpha.19

package/framework/__PROJECT_NAME__.xcodeproj/project.pbxproj

@@ -505,7 +505,7 @@
 			repositoryURL = "https://github.com/NativeScript/ios-spm.git";
 			requirement = {
 				kind = exactVersion;
-				version = "9.1.0-alpha.18";
+				version = "9.1.0-alpha.19";
 			};
 		};
 /* End XCRemoteSwiftPackageReference section */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nativescript/ios",
   "description": "NativeScript Runtime for iOS",
-  "version": "9.1.0-alpha.18",
+  "version": "9.1.0-alpha.19",
   "keywords": [
     "NativeScript",
     "iOS",
@@ -16,6 +16,7 @@
     "email": "oss@nativescript.org"
   },
   "directories": {},
+  "types": "./types/index.d.ts",
   "files": [
     "**/*"
   ],
@@ -42,7 +43,7 @@
   },
   "lint-staged": {
     "{NativeScript,metadata-generator/src,TestFixtures}/**/*.{h,hpp,c,cpp,mm,m}": [
-      "clang-format -i"
+      "tools/format-staged-native.sh"
     ],
     "NativeScript/runtime/js/**/*.js": [
       "eslint"

package/types/index.d.ts

@@ -0,0 +1,27 @@
+// Type declarations for the runtime's public `ns:` builtin modules — one
+// .d.ts per module, mirroring @types/node's layout and the "one module, one
+// source file" rule in docs/ns-builtin-modules.md. The declared surfaces must
+// stay in sync with that document (NsRuntimeTests.js / NsUtilTests.js /
+// HttpEsmLoaderTests.js assert the export sets at runtime).
+//
+// `ns:` is not a resolvable package specifier, so these are ambient
+// declarations: they apply program-wide once this file is in the TypeScript
+// program. Pull it in with either
+//
+//   /// <reference types="@nativescript/ios" />
+//
+// or a tsconfig entry:
+//
+//   { "include": ["node_modules/@nativescript/ios/types/index.d.ts"] }
+//
+// These files are the source of truth for `ns:*` types. Downstream type
+// packages must reference them, not redeclare the modules — two
+// `declare module` blocks for the same specifier conflict.
+//
+// The `node:util` compatibility shim is deliberately not declared here:
+// programs that include @types/node already have a `node:util` declaration,
+// and a second one would clash with it.
+
+/// <reference path="./ns-module.d.ts" />
+/// <reference path="./ns-runtime.d.ts" />
+/// <reference path="./ns-util.d.ts" />

package/types/ns-module.d.ts

@@ -0,0 +1,78 @@
+declare module "ns:module" {
+  /**
+   * An import map in the WHATWG shape the dev server emits: bare specifier →
+   * absolute URL. Consulted inside the engine's synchronous module resolver,
+   * which is why it must be handed to the runtime ahead of time rather than
+   * resolved on demand.
+   */
+  export interface ImportMap {
+    imports: Record<string, string>;
+  }
+
+  /**
+   * The URL vocabulary the runtime's canonical-key function applies when
+   * keying its module registry. The mechanism (fragment strip, cache-buster
+   * param drop, param sort) is native; this vocabulary is server policy and
+   * is supplied by the development tooling.
+   */
+  export interface CanonicalizationConfig {
+    /**
+     * Query param names that are pure cache busters and are dropped for dev
+     * endpoints (e.g. `t`, `v`, `import`).
+     */
+    stripParams?: string[];
+    /**
+     * Path prefixes (starts-with) identifying dev endpoints whose query may
+     * be normalized (e.g. `/ns/`, `/@id/`).
+     */
+    forPathPrefixes?: string[];
+    /**
+     * Path substrings whose query IS the module identity and must be
+     * preserved verbatim (e.g. `/@ng/component`).
+     */
+    preserveQueryFor?: string[];
+  }
+
+  /**
+   * Loader policy, installed before the dev session imports anything. Every
+   * section is optional; each present section replaces its native state
+   * wholesale.
+   */
+  export interface LoaderConfig {
+    importMap?: ImportMap;
+    /** URL substrings identifying modules that are always re-fetched, never cached. */
+    volatilePatterns?: string[];
+    canonicalization?: CanonicalizationConfig;
+  }
+
+  /**
+   * Installs loader policy — the sole channel by which server/framework URL
+   * policy enters the runtime's module loader.
+   */
+  export function configureLoader(config: LoaderConfig): void;
+
+  /**
+   * Evicts the given URLs (canonicalized) from the module registry and marks
+   * them bust-next-fetch, so the next network fetch bypasses every HTTP
+   * cache layer.
+   */
+  export function invalidateModules(urls: string[]): void;
+
+  /**
+   * The URL-like keys currently in the module registry (used to compute
+   * full-reload eviction sets).
+   */
+  export function getLoadedModuleUrls(): string[];
+
+  /**
+   * Flips the dev-boot-complete signal (defaults to `true`); disarms
+   * cold-boot-only behaviors.
+   */
+  export function setDevBootComplete(value?: boolean): void;
+
+  // Debug builds additionally carry `canonicalizeHttpUrlKey(url)`, a pure
+  // test diagnostic; release builds omit the member entirely. It is
+  // deliberately not declared here: it is not public API, and declaring it
+  // unconditionally would misrepresent release builds, where feature checks
+  // must observe it as absent.
+}

package/types/ns-runtime.d.ts

@@ -0,0 +1,46 @@
+declare module "ns:runtime" {
+  /**
+   * Controls what happens when JS touches a wrapper whose native counterpart
+   * has already been released:
+   *
+   * - `"report"` (default): the operation no-ops and a cancelable
+   *   `releasednativeaccess` event fires on `globalThis`.
+   * - `"throw"`: the touch throws a catchable `ReferenceError` synchronously,
+   *   and no event fires.
+   */
+  export type ReleasedObjectPolicy = "report" | "throw";
+
+  /**
+   * The config keys these types know about, mapped to their value domains.
+   *
+   * Keys are registered and validated natively, and other runtimes (or newer
+   * runtime versions) may register keys not listed here — `setConfig` and
+   * `getConfig` therefore accept any string key, falling back to `unknown`
+   * for the value. A runtime's own types can merge additional keys into this
+   * interface via declaration merging.
+   */
+  export interface RuntimeConfig {
+    releasedObjectPolicy: ReleasedObjectPolicy;
+  }
+
+  /**
+   * Sets a runtime config key.
+   *
+   * Throws `TypeError` on an unknown key, an invalid value, or — for
+   * process-wide keys such as `releasedObjectPolicy` — when called from a
+   * worker isolate.
+   */
+  export function setConfig<K extends keyof RuntimeConfig | (string & {})>(
+    key: K,
+    value: K extends keyof RuntimeConfig ? RuntimeConfig[K] : unknown
+  ): void;
+
+  /**
+   * Returns the current value of a config key. Readable from any isolate.
+   *
+   * Throws `TypeError` on an unknown key.
+   */
+  export function getConfig<K extends keyof RuntimeConfig | (string & {})>(
+    key: K
+  ): K extends keyof RuntimeConfig ? RuntimeConfig[K] : unknown;
+}

package/types/ns-util.d.ts

@@ -0,0 +1,26 @@
+declare module "ns:util" {
+  export interface InspectOptions {
+    /** Recursion depth for nested objects. Default: `2`. */
+    depth?: number;
+  }
+
+  /**
+   * Formats any value for human consumption: depth-limited, output-capped,
+   * cycle-safe, and never invokes getters (except a guarded `error.stack`
+   * read and custom `toString` overrides, which are honored).
+   *
+   * The output may change between runtime versions for readability; it is
+   * intended for humans and must not be parsed programmatically.
+   */
+  export function inspect(value: unknown, options?: InspectOptions): string;
+
+  /**
+   * Node-style printf formatting: `%s`, `%d`, `%i`, `%f`, `%j`, `%o`, `%O`,
+   * `%%`. Extra arguments are appended space-separated, objects rendered via
+   * {@link inspect}. When `format` is not a string or contains no
+   * substitutions, all arguments are formatted and joined with spaces.
+   *
+   * `console.*` routes its arguments through this.
+   */
+  export function format(format?: unknown, ...args: unknown[]): string;
+}