@octane-xplat/macos-renderer 0.14.0 → 0.15.0

package/src/vendor/listview/expressions.ts

@@ -0,0 +1,285 @@
+// @ts-nocheck — pinned NativeScript 9.1.3 implementation, retained for binding semantics.
+// Copyright OpenJS Foundation and contributors. MIT; see LICENSE.
+import { parse } from 'acorn';
+const isFunction = (value) => typeof value === 'function';
+const isNullOrUndefined = (value) => value == null;
+const isObject = (value) => value !== null && typeof value === 'object';
+
+interface ASTExpression {
+	readonly type: string;
+	readonly [prop: string]: any;
+}
+
+const expressionsCache = Object.create(null);
+
+const FORCED_CHAIN_VALUE = Symbol('forcedChain');
+
+// prettier-ignore
+const unaryOperators = {
+	'+': (v) => +v,
+	'-': (v) => -v,
+	'!': (v) => !v,
+	'void': (v) => void v,
+	'typeof': (v) => typeof v
+};
+
+// prettier-ignore
+const binaryOperators = {
+	'+': (l, r) => l + r,
+	'-': (l, r) => l - r,
+	'*': (l, r) => l * r,
+	'**': (l, r) => l ** r,
+	'/': (l, r) => l / r,
+	'%': (l, r) => l % r,
+	'<': (l, r) => l < r,
+	'>': (l, r) => l > r,
+	'<=': (l, r) => l <= r,
+	'>=': (l, r) => l >= r,
+	'==': (l, r) => l == r,
+	'!=': (l, r) => l != r,
+	'===': (l, r) => l === r,
+	'!==': (l, r) => l !== r,
+	'|': (l, r) => l | r,
+	'in': (l, r) => l in r,
+	'instanceof': (l, r) => l instanceof r
+};
+
+// prettier-ignore
+const logicalOperators = {
+	'&&': (l, r) => l && r(),
+	'||': (l, r) => l || r(),
+	'??': (l, r) => l ?? r()
+};
+
+// prettier-ignore
+const expressionParsers = {
+	'ArrayExpression': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		const parsed = [];
+		for (const element of expression.elements) {
+			const value = convertExpressionToValue(element, model, isBackConvert, changedModel);
+			element.type == 'SpreadElement' ? parsed.push(...value) : parsed.push(value);
+		}
+		return parsed;
+	},
+	'BinaryExpression': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		if (binaryOperators[expression.operator] == null) {
+			throw new Error('Disallowed binary operator: ' + expression.operator);
+		}
+
+		const left = convertExpressionToValue(expression.left, model, isBackConvert, changedModel);
+
+		let converterExpression = expression.right;
+		if (expression.operator == '|') {
+			if (converterExpression.type == 'ChainExpression') {
+				converterExpression = converterExpression.expression;
+			}
+			if (converterExpression.type == 'CallExpression') {
+				!converterExpression.arguments.includes(expression.left) && converterExpression.arguments.unshift(expression.left);
+				expression.right.nsIsCallable = true;
+				converterExpression = converterExpression.callee;
+			}
+
+			switch (converterExpression.type) {
+				case 'Identifier':
+				case 'MemberExpression':
+				case 'NewExpression':
+					converterExpression.nsRequiresConverter = true;
+					converterExpression.nsIsPendingCall = true;
+					break;
+				default:
+					throw new Error('Invalid converter syntax');
+			}
+		}
+
+		const right = convertExpressionToValue(expression.right, model, isBackConvert, changedModel);
+
+		if (expression.operator == '|') {
+			if (converterExpression.nsRequiresConverter) {
+				if (expression.right.nsIsCallable) {
+					return right;
+				}
+
+				if (isFunction(right)) {
+					return right(left);
+				}
+
+				if (isNullOrUndefined(right)) {
+					throw new Error('Cannot perform a call using a null or undefined property');
+				}
+			}
+			throw new Error('Invalid converter syntax');
+		}
+		return binaryOperators[expression.operator](left, right);
+	},
+	'CallExpression': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		expression.callee.nsIsPendingCall = true;
+		const callback = convertExpressionToValue(expression.callee, model, isBackConvert, changedModel);
+
+		if (!expression.optional && isNullOrUndefined(callback)) {
+			throw new Error('Cannot perform a call using a null or undefined property');
+		}
+
+		const parsedArgs = [];
+		for (const argument of expression.arguments) {
+			const value = convertExpressionToValue(argument, model, isBackConvert, changedModel);
+			argument.type == 'SpreadElement' ? parsedArgs.push(...value) : parsedArgs.push(value);
+		}
+		return expression.optional ? callback?.(...parsedArgs) : callback(...parsedArgs);
+	},
+	'ChainExpression': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		return convertExpressionToValue(expression.expression, model, isBackConvert, changedModel);
+	},
+	'ConditionalExpression': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		const test = convertExpressionToValue(expression.test, model, isBackConvert, changedModel);
+		return convertExpressionToValue(expression[test ? 'consequent' : 'alternate'], model, isBackConvert, changedModel);
+	},
+	'Identifier': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		const context = getContext(expression.name, model, changedModel);
+		let value = context[expression.name];
+		if (expression.nsRequiresConverter) {
+			value = getConverterCallback(value, isBackConvert);
+    }
+		return expression.nsIsPendingCall && typeof value === 'function' ? value.bind(context) : value;
+	},
+	'Literal': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		return expression.regex != null ? new RegExp(expression.regex.pattern, expression.regex.flags) : expression.value;
+	},
+	'LogicalExpression': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		if (logicalOperators[expression.operator] == null) {
+			throw new Error('Disallowed logical operator: ' + expression.operator);
+		}
+		const left = convertExpressionToValue(expression.left, model, isBackConvert, changedModel);
+		return logicalOperators[expression.operator](left, () => convertExpressionToValue(expression.right, model, isBackConvert, changedModel));
+	},
+	'MemberExpression': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		if (expression.object.type == 'MemberExpression') {
+			expression.object.nsIsChained = true;
+		}
+
+		const object = convertExpressionToValue(expression.object, model, isBackConvert, changedModel);
+		const property = expression.computed ? convertExpressionToValue(expression.property, model, isBackConvert, changedModel) : expression.property?.name;
+
+		/**
+		 * If an expression parent property is null or undefined, apply null-safety.
+		 * This behaviour also helps cope with components whose binding context takes a bit longer to load.
+		 * Old parser would be null-safe for properties and sub-properties
+		 * even if expression as a whole consisted of undefined ones.
+		 * The new parser will keep the same principle only if parent property is null or undefined, resulting in better control over code and errors.
+		 * It meddles with members specifically, so that it will not affect expression result as a whole.
+		 * For example, an 'isLoading || isBusy' expression will be validated as 'undefined || undefined'
+		 * if context is not ready.
+		 */
+		if (object == null && expression.object.type == 'Identifier') {
+			return expression.nsIsChained ? FORCED_CHAIN_VALUE : undefined;
+    }
+    if (object == FORCED_CHAIN_VALUE) {
+			return expression.nsIsChained ? object : undefined;
+    }
+
+    let value = expression.optional ? object?.[property] : object[property];
+    if (expression.nsRequiresConverter) {
+			value = getConverterCallback(value, isBackConvert);
+    }
+		return expression.nsIsPendingCall && typeof value === 'function' ? value.bind(object) : value;
+	},
+	'NewExpression': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		const callback = convertExpressionToValue(expression.callee, model, isBackConvert, changedModel);
+		const parsedArgs = [];
+		for (const argument of expression.arguments) {
+			const value = convertExpressionToValue(argument, model, isBackConvert, changedModel);
+			argument.type == 'SpreadElement' ? parsedArgs.push(...value) : parsedArgs.push(value);
+		}
+
+		let value = new callback(...parsedArgs);
+		if (expression.nsRequiresConverter) {
+			value = getConverterCallback(value, isBackConvert);
+    }
+    return value;
+	},
+	'ObjectExpression': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		const parsedObject = {};
+		for (const property of expression.properties) {
+			const value = convertExpressionToValue(property, model, isBackConvert, changedModel);
+			Object.assign(parsedObject, value);
+		}
+		return parsedObject;
+	},
+	'Property': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		const key = expression.computed ? convertExpressionToValue(expression.key, model, isBackConvert, changedModel) : expression.key?.name;
+		const value = convertExpressionToValue(expression.value, model, isBackConvert, changedModel);
+		return {[key]: value};
+	},
+	'SpreadElement': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		const argument = convertExpressionToValue(expression.argument, model, isBackConvert, changedModel);
+		return argument;
+	},
+	'TemplateElement': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		return expression.value.cooked;
+	},
+	'TemplateLiteral': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		let parsedText = '';
+		const length = expression.quasis.length;
+
+		for (let i = 0; i < length; i++) {
+			const q = expression.quasis[i];
+			parsedText += convertExpressionToValue(q, model, isBackConvert, changedModel);
+			if (!q.tail) {
+				parsedText += convertExpressionToValue(expression.expressions[i], model, isBackConvert, changedModel);
+			}
+		}
+		return parsedText;
+	},
+	'UnaryExpression': (expression: ASTExpression, model, isBackConvert: boolean, changedModel) => {
+		if (unaryOperators[expression.operator] == null) {
+			throw Error('Disallowed unary operator: ' + expression.operator);
+		}
+
+		const argument = convertExpressionToValue(expression.argument, model, isBackConvert, changedModel);
+		return unaryOperators[expression.operator](argument);
+	}
+};
+
+function getContext(key, model, changedModel) {
+	let context = key in changedModel ? changedModel : model;
+	if (!(key in context)) {
+		context = globalThis;
+	}
+	return context;
+}
+
+function getConverterCallback(value, isBackConvert: boolean) {
+	let callback = null;
+	if (isNullOrUndefined(value)) {
+		callback = value;
+	} else if (isFunction(value)) {
+		callback = isBackConvert ? Function.prototype : value;
+	} else if (isObject(value) && (isFunction(value.toModel) || isFunction(value.toView))) {
+		callback = (isBackConvert ? value.toModel : value.toView) || Function.prototype;
+	} else {
+		callback = value;
+	}
+	return callback;
+}
+
+export function parseExpression(expressionText: string): ASTExpression {
+	let expression = expressionsCache[expressionText];
+	if (expression == null) {
+		const program: any = parse(expressionText, { ecmaVersion: 2020 });
+		const statements = program.body;
+		for (const statement of statements) {
+			if (statement.type == 'ExpressionStatement') {
+				expression = statement.expression;
+				break;
+			}
+		}
+		expressionsCache[expressionText] = expression;
+	}
+	return expression;
+}
+
+export function convertExpressionToValue(expression: ASTExpression, model, isBackConvert: boolean, changedModel) {
+	if (!(expression.type in expressionParsers)) {
+		throw Error('Invalid expression syntax');
+	}
+	return expressionParsers[expression.type](expression, model, isBackConvert, changedModel);
+}

package/src/webview.ts

@@ -1,5 +1,19 @@
 /** Embedded document surface; deliberately has no app-shell service bridge. */
 // The minimal AppKit host links AppKit, so load WebKit before resolving classes.
+
+import {
+	NSBundle,
+	NSError,
+	NSObject,
+	NSURL,
+	NSURLErrorFailingURLErrorKey,
+	NSURLRequest,
+	WKNavigationDelegate,
+	WKWebView,
+	WKWebViewConfiguration,
+	interop,
+} from '@octane-xplat/platform/macos'
+
 const webKit = dlopen('/System/Library/Frameworks/WebKit.framework/WebKit', 2)
 if (!webKit) {
 	throw new Error('Unable to load the system WebKit framework')
@@ -161,7 +175,11 @@ export function updateWebView(
 			},
 			measure() {
 				const generation = created.generation
-				view.evaluateJavaScriptCompletionHandler(scrollScript(created.props.scrollEnabled), null)
+				view.evaluateJavaScriptCompletionHandler(
+					scrollScript(created.props.scrollEnabled),
+					null as any,
+				)
+
 				if (!created.props.matchContents && !created.props.onLayoutContent) {
 					return
 				}
@@ -228,11 +246,22 @@ export function updateWebView(
 			const url = path.startsWith('/') ? NSURL.fileURLWithPath(path) : NSURL.URLWithString(path)
 			if (!url) {
 				state.emit('onError', { url: src, error: 'Invalid document URL' })
-			} else if (url.isFileURL) {
-				state.navigation = view.loadFileURLAllowingReadAccessToURL(
-					url,
-					url.URLByDeletingLastPathComponent,
-				)
+			} else if ((url as any).isFileURL) {
+				if (src.startsWith('~/')) {
+					// Bundle-resident sources may reference sibling resources.
+					state.navigation = view.loadFileURLAllowingReadAccessToURL(
+						url,
+						url.URLByDeletingLastPathComponent,
+					)
+				} else {
+					// Any other absolute path is foreign to the bundle — grant
+					// read access to the file itself, not its whole directory.
+					console.warn(
+						'[macos-webview] file src outside the bundle is limited to the file itself; use ~/ for bundle resources',
+					)
+
+					state.navigation = view.loadFileURLAllowingReadAccessToURL(url, url)
+				}
 			} else {
 				state.navigation = view.loadRequest(NSURLRequest.requestWithURL(url))
 			}
@@ -247,6 +276,6 @@ export function updateWebView(
 
 export function disposeWebView(view: WKWebView) {
 	states.delete(view)
-	view.navigationDelegate = null
+	view.navigationDelegate = null as any
 	view.stopLoading()
 }

package/types/ARKitCore.d.ts

@@ -0,0 +1,199 @@
+/// <reference types="@nativescript/objc-node-api" />
+
+declare const ar_world_anchor_sharing_availability_t: {
+	ar_world_anchor_sharing_availability_available: 0
+	ar_world_anchor_sharing_availability_unavailable: 1
+}
+
+declare const ar_hand_chirality_t: {
+	ar_hand_chirality_right: 0
+	ar_hand_chirality_left: 1
+}
+
+declare const ar_hand_anchor_query_status_t: {
+	ar_hand_anchor_query_status_success: 0
+	ar_hand_anchor_query_status_failure: 1
+}
+
+declare const ar_hand_skeleton_joint_name_t: {
+	ar_hand_skeleton_joint_name_wrist: 0
+	ar_hand_skeleton_joint_name_thumb_knuckle: 1
+	ar_hand_skeleton_joint_name_thumb_intermediate_base: 2
+	ar_hand_skeleton_joint_name_thumb_intermediate_tip: 3
+	ar_hand_skeleton_joint_name_thumb_tip: 4
+	ar_hand_skeleton_joint_name_index_finger_metacarpal: 5
+	ar_hand_skeleton_joint_name_index_finger_knuckle: 6
+	ar_hand_skeleton_joint_name_index_finger_intermediate_base: 7
+	ar_hand_skeleton_joint_name_index_finger_intermediate_tip: 8
+	ar_hand_skeleton_joint_name_index_finger_tip: 9
+	ar_hand_skeleton_joint_name_middle_finger_metacarpal: 10
+	ar_hand_skeleton_joint_name_middle_finger_knuckle: 11
+	ar_hand_skeleton_joint_name_middle_finger_intermediate_base: 12
+	ar_hand_skeleton_joint_name_middle_finger_intermediate_tip: 13
+	ar_hand_skeleton_joint_name_middle_finger_tip: 14
+	ar_hand_skeleton_joint_name_ring_finger_metacarpal: 15
+	ar_hand_skeleton_joint_name_ring_finger_knuckle: 16
+	ar_hand_skeleton_joint_name_ring_finger_intermediate_base: 17
+	ar_hand_skeleton_joint_name_ring_finger_intermediate_tip: 18
+	ar_hand_skeleton_joint_name_ring_finger_tip: 19
+	ar_hand_skeleton_joint_name_little_finger_metacarpal: 20
+	ar_hand_skeleton_joint_name_little_finger_knuckle: 21
+	ar_hand_skeleton_joint_name_little_finger_intermediate_base: 22
+	ar_hand_skeleton_joint_name_little_finger_intermediate_tip: 23
+	ar_hand_skeleton_joint_name_little_finger_tip: 24
+	ar_hand_skeleton_joint_name_forearm_wrist: 25
+	ar_hand_skeleton_joint_name_forearm_arm: 26
+}
+
+declare const ar_transform_correction_t: {
+	ar_transform_correction_none: 0
+	ar_transform_correction_rendered: 1
+}
+
+declare const ar_session_error_code_t: {
+	ar_session_error_code_data_provider_not_authorized: 100
+	ar_session_error_code_data_provider_failed_to_run: 101
+}
+
+declare const ar_authorization_status_t: {
+	ar_authorization_status_not_determined: 0
+	ar_authorization_status_allowed: 1
+	ar_authorization_status_denied: 2
+}
+
+declare const ar_device_anchor_tracking_state_t: {
+	ar_device_anchor_tracking_state_untracked: 0
+	ar_device_anchor_tracking_state_orientation_tracked: 1
+	ar_device_anchor_tracking_state_tracked: 2
+}
+
+declare const ar_hand_fidelity_t: {
+	ar_hand_fidelity_nominal: 0
+	ar_hand_fidelity_high: 1
+}
+
+declare const ar_data_provider_state_t: {
+	ar_data_provider_state_initialized: 0
+	ar_data_provider_state_running: 1
+	ar_data_provider_state_paused: 2
+	ar_data_provider_state_stopped: 3
+}
+
+declare const ar_authorization_type_t: {
+	ar_authorization_type_none: 0
+	ar_authorization_type_hand_tracking: 1
+	ar_authorization_type_world_sensing: 2
+	ar_authorization_type_camera_access: 8
+	ar_authorization_type_accessory_tracking: 32
+}
+
+declare const ar_device_anchor_query_status_t: {
+	ar_device_anchor_query_status_success: 0
+	ar_device_anchor_query_status_failure: 1
+}
+
+declare const ar_world_tracking_error_code_t: {
+	ar_world_tracking_error_code_add_anchor_failed: 200
+	ar_world_tracking_error_code_anchor_max_limit_reached: 201
+	ar_world_tracking_error_code_remove_anchor_failed: 202
+}
+
+declare function ar_retain(object: interop.PointerConvertible): interop.Pointer
+
+declare function ar_release(object: interop.PointerConvertible): void
+
+declare interface OS_ar_world_tracking_provider extends OS_ar_data_provider {}
+
+declare class OS_ar_world_tracking_provider
+	extends NativeObject
+	implements OS_ar_world_tracking_provider {}
+
+declare interface OS_ar_world_tracking_configuration extends NSObjectProtocol {}
+
+declare class OS_ar_world_tracking_configuration
+	extends NativeObject
+	implements OS_ar_world_tracking_configuration {}
+
+declare interface OS_ar_world_anchor extends OS_ar_trackable_anchor {}
+
+declare class OS_ar_world_anchor extends NativeObject implements OS_ar_world_anchor {}
+
+declare interface OS_ar_hand_tracking_configuration extends NSObjectProtocol {}
+
+declare class OS_ar_hand_tracking_configuration
+	extends NativeObject
+	implements OS_ar_hand_tracking_configuration {}
+
+declare interface OS_ar_hand_anchor extends OS_ar_trackable_anchor {}
+
+declare class OS_ar_hand_anchor extends NativeObject implements OS_ar_hand_anchor {}
+
+declare interface OS_ar_data extends NSObjectProtocol {}
+
+declare class OS_ar_data extends NativeObject implements OS_ar_data {}
+
+declare interface OS_ar_strings extends NSObjectProtocol {}
+
+declare class OS_ar_strings extends NativeObject implements OS_ar_strings {}
+
+declare interface OS_ar_session extends NSObjectProtocol {}
+
+declare class OS_ar_session extends NativeObject implements OS_ar_session {}
+
+declare interface OS_ar_device extends NSObjectProtocol {}
+
+declare class OS_ar_device extends NativeObject implements OS_ar_device {}
+
+declare interface OS_ar_error extends NSObjectProtocol {}
+
+declare class OS_ar_error extends NativeObject implements OS_ar_error {}
+
+declare interface OS_ar_trackable_anchor extends OS_ar_anchor {}
+
+declare class OS_ar_trackable_anchor extends NativeObject implements OS_ar_trackable_anchor {}
+
+declare interface OS_ar_anchor extends NSObjectProtocol {}
+
+declare class OS_ar_anchor extends NativeObject implements OS_ar_anchor {}
+
+declare interface OS_ar_data_provider extends NSObjectProtocol {}
+
+declare class OS_ar_data_provider extends NativeObject implements OS_ar_data_provider {}
+
+declare interface OS_ar_authorization_results extends NSObjectProtocol {}
+
+declare class OS_ar_authorization_results
+	extends NativeObject
+	implements OS_ar_authorization_results {}
+
+declare interface OS_ar_hand_tracking_provider extends OS_ar_data_provider {}
+
+declare class OS_ar_hand_tracking_provider
+	extends NativeObject
+	implements OS_ar_hand_tracking_provider {}
+
+declare interface OS_ar_data_providers extends NSObjectProtocol {}
+
+declare class OS_ar_data_providers extends NativeObject implements OS_ar_data_providers {}
+
+declare interface OS_ar_hand_skeleton extends NSObjectProtocol {}
+
+declare class OS_ar_hand_skeleton extends NativeObject implements OS_ar_hand_skeleton {}
+
+declare interface OS_ar_device_anchor extends OS_ar_trackable_anchor {}
+
+declare class OS_ar_device_anchor extends NativeObject implements OS_ar_device_anchor {}
+
+declare interface OS_ar_world_anchors extends NSObjectProtocol {}
+
+declare class OS_ar_world_anchors extends NativeObject implements OS_ar_world_anchors {}
+
+declare interface OS_ar_authorization_result extends NSObjectProtocol {}
+
+declare class OS_ar_authorization_result
+	extends NativeObject
+	implements OS_ar_authorization_result {}
+
+declare interface OS_ar_skeleton_joint extends NSObjectProtocol {}
+
+declare class OS_ar_skeleton_joint extends NativeObject implements OS_ar_skeleton_joint {}