@nativescript/core 8.9.0-next-01-17-2025-12834437745 → 8.9.0-next-01-22-2025-12918162303

package/platforms/ios/typings/objc!NativeScriptUtils.d.ts

@@ -0,0 +1,18 @@
+declare class NativeScriptUtils extends NSObject {
+
+	static alloc(): NativeScriptUtils; // inherited from NSObject
+
+	static createMutableStringForSpanFontColorBackgroundColorTextDecorationBaselineOffset(text: string, font: UIFont, color: UIColor, backgroundColor: UIColor, textDecoration: string, baselineOffset: number): NSMutableAttributedString;
+
+	static createMutableStringWithDetails(details: NSDictionary<any, any>): NSMutableAttributedString;
+
+	static createUIFont(font: NSDictionary<any, any>): UIFont;
+
+	static getImageDataFormatQuality(image: UIImage, format: string, quality: number): NSData;
+
+	static getSystemFontWeightItalicSymbolicTraits(size: number, weight: number, italic: boolean, symbolicTraits: UIFontDescriptorSymbolicTraits): UIFont;
+
+	static new(): NativeScriptUtils; // inherited from NSObject
+
+	static scaleImageWidthHeightScaleFactor(image: UIImage, width: number, height: number, scaleFactor: number): UIImage;
+}

package/profiling/index.d.ts

@@ -1,33 +1,160 @@
-export declare function uptime(): number;
-export declare function log(message: string, ...optionalParams: any[]): void;
-export type InstrumentationMode = 'counters' | 'timeline' | 'lifecycle';
-export interface TimerInfo {
-    totalTime: number;
-    lastTime?: number;
-    count: number;
-    currentStart: number;
-    /**
-     * Counts the number of entry and exits a function had.
-     */
-    runCount: number;
+/**
+ * Contains contains utility methods for profiling.
+ * All methods in this module are experimental and may be changed in a non-major version.
+ */
+
+interface TimerInfo {
+	totalTime: number;
+	count: number;
 }
-export declare const time: () => number;
+
+/**
+ * Profiling mode to use.
+ *  - `counters` Accumulates method call counts and times until dumpProfiles is called and then prints aggregated statistic in the console. This is the default.
+ *  - `timeline` Outputs method names along start/end timestamps in the console on the go.
+ *  - `lifecycle` Outputs basic non-verbose times for startup, navigation, etc.
+ */
+type InstrumentationMode = 'counters' | 'timeline' | 'lifecycle';
+
+/**
+ * Logging levels in order of verbosity.
+ */
+export enum Level {
+	none,
+	lifecycle,
+	timeline,
+}
+
+/**
+ * Get the current logging level.
+ */
+export function level(): Level;
+
+/**
+ * Enables profiling.
+ *
+ * Upon loading of the module it will cache the package.json of the app and check if there is a "profiling" key set,
+ * its value can be one of the options available for InstrumentationMode, and if set,
+ * enable() will be called in pre app start with the value in the package.json.
+ *
+ * An example for an `app/package.json` enabling the manual instrumentation profiling is:
+ * ```
+ * {
+ *     "main": "main.js",
+ *     "profiling": "timeline"
+ * }
+ * ```
+ *
+ * @param type Profiling mode to use.
+ *  - "counters" - Accumulates method call counts and times until dumpProfiles is called and then prints aggregated statistic in the console. This is the default.
+ *  - "timeline" - Outputs method names along start/end timestamps in the console on the go.
+ *  - "lifecycle" - Outputs basic non-verbose times for startup, navigation, etc.
+ */
+export declare function enable(type?: InstrumentationMode): void;
+
+/**
+ * Disables profiling.
+ */
+export declare function disable(): void;
+
+/**
+ * Gets accurate system timestamp in ms.
+ */
+export declare function time(): number;
+
+/**
+ * Starts a timer with a specific name.
+ * Works only if profiling is enabled.
+ * @param name Name of the timer.
+ */
 export declare function start(name: string): void;
+
+/**
+ * Pauses a timer with a specific name. This will increase call count and accumulate time.
+ * Works only if profiling is enabled.
+ * @param name Name of the timer.
+ * @returns TimerInfo for the paused timer.
+ */
 export declare function stop(name: string): TimerInfo;
-export declare function timer(name: string): TimerInfo;
-export declare function print(name: string): TimerInfo;
+
+/**
+ * Read a timer info.
+ * @param name The name of the timer to obtain information about.
+ */
+export function timer(name: string): TimerInfo;
+
+/**
+ * Returns true if a timer is currently running.
+ * @param name Name of the timer.
+ * @returns true is the timer is currently running.
+ */
 export declare function isRunning(name: string): boolean;
-export declare enum Level {
-    none = 0,
-    lifecycle = 1,
-    timeline = 2
-}
-export declare function enable(mode?: InstrumentationMode): void;
-export declare function disable(): void;
-export declare function profile(nameFnOrTarget?: string | Function | Object, fnOrKey?: Function | string | symbol, descriptor?: PropertyDescriptor, attrs?: any): any;
+
+/**
+ * Method decorator factory. It will intercept the method call and start and pause a timer before and after the method call.
+ * Works only if profiling is enabled.
+ * @param name Name of the timer which will be used for method calls. If not provided - the name of the method will be used.
+ */
+export declare function profile(name?: string): MethodDecorator;
+
+/**
+ * Function factory. It will intercept the function call and start and pause a timer before and after the function call. Works only if profiling is enabled.
+ * Works only if profiling is enabled.
+ * @param fn The function to wrap. Uses the function name to track the times.
+ */
+export declare function profile<F extends Function>(fn: F): F;
+
+/**
+ * Function factory. It will intercept the function call and start and pause a timer before and after the function call. Works only if profiling is enabled.
+ * @param name The name used to track calls and times.
+ * @param fn The function to wrap.
+ */
+export declare function profile<F extends Function>(name: string, fn: F): F;
+
+/**
+ * Method decorator. It will intercept the method calls and start and pause a timer before and after the method call. Works only if profiling is enabled.
+ */
+export declare function profile<T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T> | void;
+export function profile(): any;
+
+/**
+ * Prints the timer for all methods instrumented with profile decorator.
+ */
 export declare function dumpProfiles(): void;
-export declare function resetProfiles(): void;
+
+/**
+ * Resets the timers for all methods instrumented with profile decorator.
+ */
+export function resetProfiles(): void;
+
+/**
+ * Starts android cpu profiling.
+ * @param name Name of the cpu profiling session.
+ */
 export declare function startCPUProfile(name: string): void;
+
+/**
+ * Stops android cpu profiling.
+ * @param name Name of the cpu profiling session.
+ */
 export declare function stopCPUProfile(name: string): void;
-export declare function level(): Level;
-export declare function trace(message: string, start: number, end: number): void;
+
+/**
+ * Gets the uptime of the current process in milliseconds.
+ */
+export function uptime(): number;
+
+/**
+ * Logs important messages. Contrary to console.log's behavior, the profiling log should output even for release builds.
+ */
+export function log(message: string): void;
+
+/**
+ * Manually output profiling messages. The `@profile` decorator is useful when measuring times that function calls take on the stack
+ * but when measuring times between longer periods (startup times, times between the navigatingTo - navigatedTo events etc.)
+ * you can call this method and provide manually the times to be logged.
+ * @param message A string message
+ * @param start The start time (see `time()`)
+ * @param end The end time (see `time()`)
+ */
+export function trace(message: string, start: number, end: number): void;

package/references.d.ts

@@ -0,0 +1,10 @@
+/// <reference path="../types-ios/src/index.d.ts" />
+/// <reference path="../types-ios/src/lib/ios/objc-x86_64/objc!CFNetwork.d.ts" />
+/// <reference path="../types-ios/src/lib/ios/objc-x86_64/objc!CoreText.d.ts" />
+/// <reference path="../types-ios/src/lib/ios/objc-x86_64/objc!Darwin.d.ts" />
+/// <reference path="../types-ios/src/lib/ios/objc-x86_64/objc!DarwinFoundation.d.ts" />
+/// <reference path="../types-ios/src/lib/ios/objc-x86_64/objc!Symbols.d.ts" />
+/// <reference path="../types-android/src/lib/android-29.d.ts" />
+/// <reference path="./platforms/ios/typings/objc!MaterialComponents.d.ts" />
+/// <reference path="./platforms/ios/typings/objc!NativeScriptUtils.d.ts" />
+/// <reference path="./global-types.d.ts" />

package/text/formatted-string.d.ts

@@ -1 +1 @@
-export * from '../ui/text-base/formatted-string';
+export * from '../ui/text-base/formatted-string';

package/text/index.d.ts

@@ -0,0 +1,36 @@
+export * from './text-common';
+
+/**
+ * Defines the supported character encodings.
+ */
+export namespace encoding {
+	/**
+	 * Denotes ISO-8859-1 character encoding.
+	 */
+	export const ISO_8859_1: any;
+
+	/**
+	 * Denotes US_ASCII character encoding.
+	 */
+	export const US_ASCII: any;
+
+	/**
+	 * Denotes UTF_16 character encoding.
+	 */
+	export const UTF_16: any;
+
+	/**
+	 * Denotes UTF_16BE character encoding.
+	 */
+	export const UTF_16BE: any;
+
+	/**
+	 * Denotes UTF_16LE character encoding.
+	 */
+	export const UTF_16LE: any;
+
+	/**
+	 * Denotes UTF_8 character encoding.
+	 */
+	export const UTF_8: any;
+}

package/text/span.d.ts

@@ -1 +1 @@
-export * from '../ui/text-base/span';
+export * from '../ui/text-base/span';

package/timer/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Calls a function after a specified delay.
+ * @param callback The function to be called.
+ * @param milliseconds The time to wait before the function is called. Defaults to 0.
+ * @param args One or more parameter to use once the function is called. Defaults to no parameters.
+ */
+export function setTimeout(callback: Function, milliseconds?: number, ...args: any[]): number;
+
+/**
+ * Clears the delay set by a call to the setTimeout function.
+ * @param id The identifier returned by the previously called setTimeout() method.
+ */
+export function clearTimeout(id: number): void;
+
+/**
+ * Calls a function repeatedly with a delay between each call.
+ * @param callback The function to be called.
+ * @param milliseconds The delay between each function call.
+ * @param args One or more parameter to use once the function is called. Defaults to no parameters.
+ */
+export function setInterval(callback: Function, milliseconds?: number, ...args: any[]): number;
+
+/**
+ * Clears repeated function which was set up by calling setInterval().
+ * @param id The identifier returned by the setInterval() method.
+ */
+export function clearInterval(id: number): void;

package/trace/index.d.ts

@@ -2,120 +2,146 @@
  * An interface used to define a writer used by trace to print (log).
  */
 export interface TraceWriter {
-    write(message: any, category: string, type?: number): void;
+	write(message: any, category: string, type?: number): void;
 }
+
 /**
  * An interface used to trace information about specific event.
  */
 export interface TraceEventListener {
-    filter: string;
-    on(object: Object, name: string, data?: any): void;
+	filter: string;
+	on(object: Object, name: string, data?: any): void;
 }
+
 /**
  * An interface used to for handling trace error
  */
 export interface TraceErrorHandler {
-    handlerError(error: Error): any;
+	handlerError(error: Error): any;
 }
-export declare namespace Trace {
-    /**
-     * Enables the trace module.
-     */
-    function enable(): void;
-    /**
-     * Disables the trace module.
-     */
-    function disable(): void;
-    /**
-     * A function that returns whether the tracer is enabled and there is a point in writing messages.
-     * Check this to avoid writing complex string templates.
-     * Send error messages even if tracing is disabled.
-     */
-    function isEnabled(): boolean;
-    /**
-     * Adds a TraceWriter instance to the trace module.
-     * @param writer The TraceWriter instance to add.
-     */
-    function addWriter(writer: TraceWriter): void;
-    /**
-     * Removes a TraceWriter instance from the trace module.
-     * @param writer The TraceWriter instance to remove.
-     */
-    function removeWriter(writer: TraceWriter): void;
-    /**
-     * Clears all the writers from the trace module.
-     */
-    function clearWriters(): void;
-    /**
-     * Sets the categories the module will trace.
-     * @param categories The comma-separated list of categories. If not specified all messages from all categories will be traced.
-     */
-    function setCategories(categories: string): void;
-    /**
-     * Adds categories to existing categories the module will trace.
-     * @param categories The comma-separated list of categories. If not specified all messages from all categories will be traced.
-     */
-    function addCategories(categories: string): void;
-    /**
-     * Check if category is already set in trace module.
-     * @param category The category to check.
-     */
-    function isCategorySet(category: string): boolean;
-    /**
-     * Writes a message using the available writers.
-     * @param message The message to be written.
-     * @param category The category of the message.
-     * @param type Optional, the type of the message - info, warning, error.
-     */
-    function write(message: any, category: string, type?: number): void;
-    /**
-     * Notifies all the attached listeners for an event that has occurred in the sender object.
-     * @param object The Object instance that raised the event.
-     * @param name The name of the raised event.
-     * @param data An optional parameter that passes the data associated with the event.
-     */
-    function notifyEvent(object: Object, name: string, data?: any): void;
-    function addEventListener(listener: TraceEventListener): void;
-    function removeEventListener(listener: TraceEventListener): void;
-    namespace messageType {
-        const log = 0;
-        const info = 1;
-        const warn = 2;
-        const error = 3;
-    }
-    /**
-     * all predefined categories.
-     */
-    namespace categories {
-        const Accessibility = "Accessibility";
-        const VisualTreeEvents = "VisualTreeEvents";
-        const Layout = "Layout";
-        const Style = "Style";
-        const ViewHierarchy = "ViewHierarchy";
-        const NativeLifecycle = "NativeLifecycle";
-        const Debug = "Debug";
-        const Navigation = "Navigation";
-        const Test = "Test";
-        const Binding = "Binding";
-        const BindingError = "BindingError";
-        const Error = "Error";
-        const Animation = "Animation";
-        const Transition = "Transition";
-        const Livesync = "Livesync";
-        const ModuleNameResolver = "ModuleNameResolver";
-        const MediaQuery = "MediaQuery";
-        const separator = ",";
-        const All: string;
-        function concat(...args: any): string;
-    }
-    class DefaultErrorHandler implements TraceErrorHandler {
-        handlerError(error: any): void;
-    }
-    function getErrorHandler(): TraceErrorHandler;
-    function setErrorHandler(handler: TraceErrorHandler): void;
-    /**
-     * Passes an error to the registered ErrorHandler
-     * @param error The error to be handled.
-     */
-    function error(error: string | Error): void;
+
+export namespace Trace {
+	/**
+	 * Enables the trace module.
+	 */
+	export function enable(): void;
+
+	/**
+	 * Disables the trace module.
+	 */
+	export function disable(): void;
+
+	/**
+	 * A function that returns whether the tracer is enabled and there is a point in writing messages.
+	 * Check this to avoid writing complex string templates.
+	 * Send error messages even if tracing is disabled.
+	 */
+	export function isEnabled(): boolean;
+
+	/**
+	 * Adds a TraceWriter instance to the trace module.
+	 * @param writer The TraceWriter instance to add.
+	 */
+	export function addWriter(writer: TraceWriter): void;
+
+	/**
+	 * Removes a TraceWriter instance from the trace module.
+	 * @param writer The TraceWriter instance to remove.
+	 */
+	export function removeWriter(writer: TraceWriter): void;
+
+	/**
+	 * Clears all the writers from the trace module.
+	 */
+	export function clearWriters(): void;
+
+	/**
+	 * Sets the categories the module will trace.
+	 * @param categories The comma-separated list of categories. If not specified all messages from all categories will be traced.
+	 */
+	export function setCategories(categories: string): void;
+
+	/**
+	 * Adds categories to existing categories the module will trace.
+	 * @param categories The comma-separated list of categories. If not specified all messages from all categories will be traced.
+	 */
+	export function addCategories(categories: string): void;
+
+	/**
+	 * Check if category is already set in trace module.
+	 * @param category The category to check.
+	 */
+	export function isCategorySet(category: string): boolean;
+
+	/**
+	 * Writes a message using the available writers.
+	 * @param message The message to be written.
+	 * @param category The category of the message.
+	 * @param type Optional, the type of the message - info, warning, error.
+	 */
+	export function write(message: any, category: string, type?: number): void;
+
+	/**
+	 * Notifies all the attached listeners for an event that has occurred in the sender object.
+	 * @param object The Object instance that raised the event.
+	 * @param name The name of the raised event.
+	 * @param data An optional parameter that passes the data associated with the event.
+	 */
+	export function notifyEvent(object: Object, name: string, data?: any): void;
+
+	export function addEventListener(listener: TraceEventListener): void;
+
+	export function removeEventListener(listener: TraceEventListener): void;
+
+	export module messageType {
+		export const log = 0;
+		export const info = 1;
+		export const warn = 2;
+		export const error = 3;
+	}
+
+	/**
+	 * all predefined categories.
+	 */
+	export module categories {
+		export const VisualTreeEvents = 'VisualTreeEvents';
+		export const Layout = 'Layout';
+		export const Style = 'Style';
+		export const ViewHierarchy = 'ViewHierarchy';
+		export const NativeLifecycle = 'NativeLifecycle';
+		export const Debug = 'Debug';
+		export const Navigation = 'Navigation';
+		export const Test = 'Test';
+		export const Binding = 'Binding';
+		export const BindingError = 'BindingError';
+		export const Error = 'Error';
+		export const Animation = 'Animation';
+		export const Transition = 'Transition';
+		export const Livesync = 'Livesync';
+		export const ModuleNameResolver = 'ModuleNameResolver';
+		export const MediaQuery = 'MediaQuery';
+
+		export const separator = ',';
+		export const All: string;
+
+		export function concat(...args: any): string;
+	}
+
+	class ConsoleWriter implements TraceWriter {
+		public write(message: any, category: string, type?: number): void;
+	}
+
+	export class DefaultErrorHandler implements TraceErrorHandler {
+		handlerError(error: any): void;
+	}
+
+	export function getErrorHandler(): TraceErrorHandler;
+
+	export function setErrorHandler(handler: TraceErrorHandler): void;
+
+	/**
+	 * Passes an error to the registered ErrorHandler
+	 * @param error The error to be handled.
+	 */
+	export function error(error: string | Error): void;
 }