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

package/css/reworkcss.d.ts

@@ -0,0 +1,47 @@
+export interface Position {
+	start: { line: number; column: number };
+	end: { line: number; column: number };
+}
+
+export interface Node {
+	type: 'rule' | 'keyframes' | 'declaration' | 'import' | 'media';
+	position: Position;
+}
+
+export interface Declaration extends Node {
+	property: string;
+	value: string;
+}
+
+export interface Rule extends Node {
+	selectors: string[];
+	declarations: Declaration[];
+}
+
+export type AtRule = KeyFrames | Media;
+
+export interface Keyframes extends Rule {
+	name: string;
+	vendor?: string;
+	keyframes?: Array<KeyFrame>;
+}
+
+export interface KeyFrame extends Node {
+	values: string[];
+	declarations: Array<Declaration>;
+}
+
+export interface Media extends Node {
+	media: string;
+	rules: Array<Rule | AtRule>;
+}
+
+export interface StyleSheet {
+	rules: Rule[];
+}
+
+export interface SyntaxTree {
+	stylesheet: StyleSheet;
+}
+
+export function parse(css: string, options: any): SyntaxTree;

package/css/reworkcss.js

@@ -0,0 +1 @@
+exports.parse = require('./lib/parse');

package/css-value/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "css-value",
+  "version": "0.0.1",
+  "description": "CSS value parser",
+  "keywords": [
+    "css",
+    "parser",
+    "value"
+  ],
+  "author": "TJ Holowaychuk <tj@vision-media.ca>",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/visionmedia/css-value.git"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "mocha": "~1.9.0",
+    "should": "~1.2.2"
+  },
+  "main": "reworkcss-value",
+  "types": "reworkcss-value.d.ts",
+  "nativescript": {}
+}

package/css-value/reworkcss-value.d.ts

@@ -0,0 +1,8 @@
+interface CSSValue {
+	type: string;
+	string: string;
+	unit?: string;
+	value?: number;
+}
+
+export function parse(cssValue: string): Array<CSSValue>;

package/css-value/reworkcss-value.js

@@ -0,0 +1,113 @@
+
+exports.parse = parse;
+
+function parse(str) {
+  return new Parser(str).parse();
+}
+
+function Parser(str) {
+  this.str = str;
+}
+
+Parser.prototype.skip = function(m){
+  this.str = this.str.slice(m[0].length);
+};
+
+Parser.prototype.comma = function(){
+  var m = /^, */.exec(this.str);
+  if (!m) return;
+  this.skip(m);
+  return { type: 'comma', string: ',' };
+};
+
+Parser.prototype.ident = function(){
+  var m = /^([\w-]+) */.exec(this.str);
+  if (!m) return;
+  this.skip(m);
+  return {
+    type: 'ident',
+    string: m[1]
+  }
+};
+
+Parser.prototype.int = function(){
+  var m = /^(([-\+]?\d+)(\S+)?) */.exec(this.str);
+  if (!m) return;
+  this.skip(m);
+  var n = ~~m[2];
+  var u = m[3];
+
+  return {
+    type: 'number',
+    string: m[1],
+    unit: u || '',
+    value: n
+  }
+};
+
+Parser.prototype.float = function(){
+  var m = /^(((?:[-\+]?\d+)?\.\d+)(\S+)?) */.exec(this.str);
+  if (!m) return;
+  this.skip(m);
+  var n = parseFloat(m[2]);
+  var u = m[3];
+
+  return {
+    type: 'number',
+    string: m[1],
+    unit: u || '',
+    value: n
+  }
+};
+
+Parser.prototype.number = function(){
+  return this.float() || this.int();
+};
+
+Parser.prototype.double = function(){
+  var m = /^"([^"]*)" */.exec(this.str);
+  if (!m) return m;
+  this.skip(m);
+  return {
+    type: 'string',
+    quote: '"',
+    string: '"' + m[1] + '"',
+    value: m[1]
+  }
+};
+
+Parser.prototype.single = function(){
+  var m = /^'([^']*)' */.exec(this.str);
+  if (!m) return m;
+  this.skip(m);
+  return {
+    type: 'string',
+    quote: "'",
+    string: "'" + m[1] + "'",
+    value: m[1]
+  }
+};
+
+Parser.prototype.string = function(){
+  return this.single() || this.double();
+};
+
+
+Parser.prototype.value = function(){
+  return this.number()
+    || this.ident()
+    || this.string()
+    || this.comma();
+};
+
+Parser.prototype.parse = function(){
+  var vals = [];
+
+  while (this.str.length) {
+    var obj = this.value();
+    if (!obj) throw new Error('failed to parse near `' + this.str.slice(0, 10) + '...`');
+    vals.push(obj);
+  }
+
+  return vals;
+};

package/debugger/css-agent.d.ts

@@ -0,0 +1,59 @@
+export interface CSSProperty {
+	name: string;
+	value: string;
+	disabled: boolean;
+}
+export interface ShorthandEntry {
+	name: string;
+	value: string;
+}
+export interface CSSStyle {
+	cssProperties: CSSProperty[];
+	shorthandEntries: ShorthandEntry[];
+	cssText?: string;
+}
+export interface Value {
+	text: string;
+}
+export interface SelectorList {
+	selectors: Value[];
+	text: string;
+}
+export interface CSSRule {
+	selectorList: SelectorList;
+	origin: string;
+	style: CSSStyle;
+	styleSheetId?: string;
+}
+export interface RuleMatch {
+	rule: CSSRule;
+	matchingSelectors: number[];
+}
+export interface InheritedStyleEntry {
+	matchedCSSRules: RuleMatch[];
+	inlineStyle?: CSSStyle;
+}
+export interface CSSComputedStyleProperty {
+	name: string;
+	value: string;
+}
+export interface PlatformFontUsage {
+	familyName: string;
+	glyphCount: number;
+	isCustomFont: boolean;
+}
+export interface CSSStyleSheetHeader {
+	styleSheetId: string;
+	frameId: string;
+	sourceUrl: string;
+	origin: string;
+	title: string;
+	disabled: boolean;
+	isInLine: boolean;
+	startLine: number;
+	startColumn: number;
+}
+export interface PseudoElementMatches {
+	pseudoType: string;
+	matches: RuleMatch[];
+}

package/debugger/devtools-elements.d.ts

@@ -1,5 +1,23 @@
-import { InspectorEvents, InspectorCommands } from './devtools-elements-interfaces';
-export * from './devtools-elements-interfaces';
-export declare function attachDOMInspectorEventCallbacks(DOMDomainFrontend: InspectorEvents): void;
-export declare function attachDOMInspectorCommandCallbacks(DOMDomainBackend: InspectorCommands): void;
-export declare function attachCSSInspectorCommandCallbacks(CSSDomainBackend: InspectorCommands): void;
+import { DOMNode } from './dom-node';
+
+export interface InspectorCommands {
+	// DevTools -> Application communication. Methods that devtools calls when needed.
+	getDocument(): string | DOMNode;
+	removeNode(nodeId: number): void;
+	getComputedStylesForNode(nodeId: number): string | Array<{ name: string; value: string }>;
+	setAttributeAsText(nodeId: number, text: string, name: string): void;
+}
+
+export interface InspectorEvents {
+	// Application -> DevTools communication. Methods that the app should call when needed.
+	childNodeInserted(parentId: number, lastId: number, node: DOMNode): void;
+	childNodeRemoved(parentId: number, nodeId: number): void;
+	attributeModified(nodeId: number, attrName: string, attrValue: string): void;
+	attributeRemoved(nodeId: number, attrName: string): void;
+}
+
+export function attachDOMInspectorEventCallbacks(inspector: InspectorEvents);
+
+export function attachDOMInspectorCommandCallbacks(inspector: InspectorCommands);
+
+export function attachCSSInspectorCommandCallbacks(inspector: InspectorCommands);

package/debugger/dom-node.d.ts

@@ -1,24 +1,27 @@
-import { CSSComputedStyleProperty } from './css-agent';
-import { InspectorEvents } from './devtools-elements-interfaces';
 import { ViewBase } from '../ui/core/view-base';
-export declare function registerInspectorEvents(inspector: InspectorEvents): void;
+import { CSSComputedStyleProperty } from './css-agent';
 export declare function getNodeById(id: number): DOMNode;
+declare class WeakRef<T> {
+	constructor(obj: T);
+	get(): T;
+	clear(): void;
+}
 export declare class DOMNode {
-    nodeId: any;
-    nodeType: any;
-    nodeName: any;
-    localName: any;
-    nodeValue: string;
-    attributes: string[];
-    viewRef: WeakRef<ViewBase>;
-    constructor(view: ViewBase);
-    loadAttributes(): void;
-    get children(): DOMNode[];
-    onChildAdded(childView: ViewBase): void;
-    onChildRemoved(view: ViewBase): void;
-    attributeModified(name: string, value: any): void;
-    attributeRemoved(name: string): void;
-    getComputedProperties(): CSSComputedStyleProperty[];
-    dispose(): void;
-    toObject(): any;
+	nodeId: any;
+	nodeType: any;
+	nodeName: any;
+	localName: any;
+	nodeValue: string;
+	attributes: string[];
+	viewRef: WeakRef<ViewBase>;
+	constructor(view: ViewBase);
+	loadAttributes(): void;
+	readonly children: DOMNode[];
+	onChildAdded(childView: ViewBase): void;
+	onChildRemoved(view: ViewBase): void;
+	attributeModified(name: string, value: any): void;
+	attributeRemoved(name: string): void;
+	getComputedProperties(): CSSComputedStyleProperty[];
+	dispose(): void;
+	toJSON(): string;
 }