x-runtime-lib 0.8.28 → 0.8.31

package/dist/types/data.d.ts

@@ -12,24 +12,24 @@ export interface Node {
 export interface View {
     nodes: Node[];
 }
-interface TriggerElementProp {
-    type: 'elementProp';
+interface TriggerElementProperty {
+    type: 'elementProperty';
     nodeId: string;
-    propKeys: string;
+    propertyKeys: string;
 }
-interface TriggerCustomProp {
-    type: 'customProp';
-    propId: string;
+interface TriggerCustomProperty {
+    type: 'customProperty';
+    propertyId: string;
 }
 interface TriggerCustomState {
     type: 'customState';
     stateId: string;
 }
-interface TriggerAdaptSlotProp {
-    type: 'adaptSlotProp';
-    propId: string;
+interface TriggerAdaptSlotProperty {
+    type: 'adaptSlotProperty';
+    propertyId: string;
 }
-export type Trigger = (TriggerElementProp | TriggerCustomProp | TriggerCustomState | TriggerAdaptSlotProp) & {
+export type Trigger = (TriggerElementProperty | TriggerCustomProperty | TriggerCustomState | TriggerAdaptSlotProperty) & {
     subKeys?: string;
 };
 export interface Reactivity {

package/dist/types/element.d.ts

@@ -22,28 +22,28 @@ type ZTypeNumInput = {
     default: string;
 } & ZTypeBase;
 export type ZType = ZTypeWord | ZTypeNumInput;
-type ZPropBase = {
+type ZPropertyBase = {
     key: string;
     name: string;
 };
-type ZPropBranch = {
+type ZPropertyBranch = {
     ui?: undefined;
-    children: ZProp[];
+    children: ZProperty[];
     default?: undefined;
-} & ZPropBase;
-type ZPropDummy = {
+} & ZPropertyBase;
+type ZPropertyDummy = {
     ui: 'dummy';
     readonly?: boolean;
     default: string | number | boolean | object | undefined;
-} & ZPropBase;
-type ZPropStrInput = {
+} & ZPropertyBase;
+type ZPropertyStrInput = {
     ui: 'strInput';
     readonly?: boolean;
     static?: boolean;
     value?: unknown;
     default: string;
-} & ZPropBase;
-type ZPropNumInput = {
+} & ZPropertyBase;
+type ZPropertyNumInput = {
     ui: 'numInput';
     precision?: number;
     min?: number;
@@ -51,92 +51,92 @@ type ZPropNumInput = {
     step?: number;
     readonly?: boolean;
     default: number;
-} & ZPropBase;
-type ZPropSwitch = {
+} & ZPropertyBase;
+type ZPropertySwitch = {
     ui: 'switch';
     readonly?: boolean;
     default: boolean;
-} & ZPropBase;
-type ZPropSelect = {
+} & ZPropertyBase;
+type ZPropertySelect = {
     ui: 'select';
     items: 'alignTabsItemsV1' | 'axisTypeItemsV1' | 'borderStyleItemsV1' | 'colorModeItemsV1' | 'densityItemsV1' | 'directionItemsV1' | 'fieldVariantItemsV1' | 'flexCrossAlignItemsV1' | 'flexDirectionItemsV1' | 'flexMainAlignItemsV1' | 'flexWrapItemsV1' | 'fontWeightItemsV1' | 'sheetVariantItemsV1' | 'showTicksItemsV1' | 'sizeItemsV1' | 'textAlignItemsV1' | 'textDecorationItemsV1' | 'textEmphasisItemsV1' | 'textStyleItemsV1' | 'themeColorItemsV1' | 'thumbLabelItemsV1' | 'timelineAlignItemsV1' | 'timelineDirectionItemsV1' | 'timelineSideItemsV1' | 'timelineTruncateLineItemsV1';
     readonly?: boolean;
     default: string;
-} & ZPropBase;
-type ZPropColorPicker = {
+} & ZPropertyBase;
+type ZPropertyColorPicker = {
     ui: 'colorPicker';
     readonly?: boolean;
     default: string | undefined;
-} & ZPropBase;
-type ZPropJsonEditor = {
+} & ZPropertyBase;
+type ZPropertyJsonEditor = {
     ui: 'jsonEditor';
     readonly?: boolean;
     default: string;
-} & ZPropBase;
-type ZPropMultiTypes = {
+} & ZPropertyBase;
+type ZPropertyMultiTypes = {
     ui: 'multiTypes';
     types: 'borderWidthTypesV1' | 'leftRightTypesV1' | 'marginTypesV1' | 'paddingTypesV1' | 'sizeTypesV1' | 'tableColumnAlignTypesV1' | 'topBottomTypesV1';
     readonly?: boolean;
     default: string;
-} & ZPropBase;
-type ZPropCompSelect = {
+} & ZPropertyBase;
+type ZPropertyCompSelect = {
     ui: 'compSelect';
     readonly?: boolean;
     default: string | undefined;
-} & ZPropBase;
-export type ZProp = ({
+} & ZPropertyBase;
+export type ZProperty = ({
     array?: false;
-} & ZPropBranch) | ({
+} & ZPropertyBranch) | ({
     array: true;
     defaultArray: object[];
-} & ZPropBranch) | ({
+} & ZPropertyBranch) | ({
     array?: false;
-} & ZPropDummy) | ({
+} & ZPropertyDummy) | ({
     array: true;
     defaultArray: string[] | number[] | boolean | object[];
-} & ZPropDummy) | ({
+} & ZPropertyDummy) | ({
     array?: false;
-} & ZPropStrInput) | ({
+} & ZPropertyStrInput) | ({
     array: true;
     defaultArray: string[];
-} & ZPropStrInput) | ({
+} & ZPropertyStrInput) | ({
     array?: false;
-} & ZPropNumInput) | ({
+} & ZPropertyNumInput) | ({
     array: true;
     defaultArray: number[];
-} & ZPropNumInput) | ({
+} & ZPropertyNumInput) | ({
     array?: false;
-} & ZPropSwitch) | ({
+} & ZPropertySwitch) | ({
     array: true;
     defaultArray: boolean[];
-} & ZPropSwitch) | ({
+} & ZPropertySwitch) | ({
     array?: false;
-} & ZPropSelect) | ({
+} & ZPropertySelect) | ({
     array: true;
     defaultArray: string[];
-} & ZPropSelect) | ({
+} & ZPropertySelect) | ({
     array?: false;
-} & ZPropColorPicker) | ({
+} & ZPropertyColorPicker) | ({
     array: true;
     defaultArray: string[];
-} & ZPropColorPicker) | ({
+} & ZPropertyColorPicker) | ({
     array?: false;
-} & ZPropJsonEditor) | ({
+} & ZPropertyJsonEditor) | ({
     array: true;
     defaultArray: string[];
-} & ZPropJsonEditor) | ({
+} & ZPropertyJsonEditor) | ({
     array?: false;
-} & ZPropMultiTypes) | ({
+} & ZPropertyMultiTypes) | ({
     array: true;
     defaultArray: string[];
-} & ZPropMultiTypes) | ({
+} & ZPropertyMultiTypes) | ({
     array?: false;
-} & ZPropCompSelect) | ({
+} & ZPropertyCompSelect) | ({
     array: true;
     defaultArray: string[];
-} & ZPropCompSelect);
-export type ZProps = {
-    [key: string]: ZProp[];
+} & ZPropertyCompSelect);
+export type ZProperties = {
+    [key: string]: ZProperty[];
 };
 export type ZEvent = {
     key: string;
@@ -190,7 +190,7 @@ export type ZElement = {
     key: string;
     name: string;
     comp: any;
-    props: ZProps;
+    properties: ZProperties;
     events: ZEvent[];
     methods: ZMethod[];
     slots: ZSlot[];

package/dist/utils/index.d.ts

@@ -1,7 +1,7 @@
 export * from './misc';
 export * from './name';
 export * from './node';
-export * from './prop';
+export * from './property';
 export * from './provideInject';
 export * from './reactivity';
 export * from './sandbox';

package/dist/utils/name.d.ts

@@ -1,3 +1,4 @@
-export declare function toPropertyName(id: string, names: string[]): string;
-export declare function toMethodName(id: string, names: string[]): string;
-export declare function toEventName(id: string, names: string[]): string;
+import { EventKind, MethodKind, PropertyKind } from '@/types';
+export declare function toPropertyName(kind: PropertyKind, names: string[]): string;
+export declare function toMethodName(kind: MethodKind, names: string[]): string;
+export declare function toEventName(kind: EventKind, names: string[]): string;

package/dist/utils/property.d.ts

@@ -0,0 +1,4 @@
+import { ZProperty } from '@/types';
+export declare function getPropertyTag(type: string, subtype: string): string | undefined;
+export declare function getPropertyDefault(property: ZProperty, arrayEntry?: boolean): unknown;
+export declare function initProperties(node: any, properties: ZProperty[]): void;

package/dist/utils/sandbox.d.ts

@@ -1,10 +1,10 @@
 import { Data, Env, Mode } from '@/types';
-export type PropKeys = string[] | string;
+export type PropertyKeys = string[] | string;
 interface Hooks {
-    onElementPropChange: (nodeId: string, propKeys: PropKeys, newValue: any, oldValue: any) => void;
-    onCustomPropChange: (propId: string, newValue: any, oldValue: any) => void;
+    onElementPropertyChange: (nodeId: string, propertyKeys: PropertyKeys, newValue: any, oldValue: any) => void;
+    onCustomPropertyChange: (propertyId: string, newValue: any, oldValue: any) => void;
     onCustomStateChange: (stateId: string, newValue: any, oldValue: any) => void;
-    onAdaptSlotPropChange: (propId: string, newValue: any, oldValue: any) => void;
+    onAdaptSlotPropertyChange: (propertyId: string, newValue: any, oldValue: any) => void;
 }
 export declare class Sandbox {
     org: string;
@@ -16,22 +16,22 @@ export declare class Sandbox {
     constructor(org: string, env: Env, mode: Mode, type: 'page' | 'comp', hooks?: Hooks);
     private nodes;
     syncNodes(data: Data | undefined): void;
-    getElementPropInner(node: any, propKeys: PropKeys): any;
-    getElementProp(nodeId: string, propKeys: PropKeys): any;
-    setElementPropInner(node: any, propKeys: PropKeys, newValue: any): void;
-    setElementProp(nodeId: string, propKeys: PropKeys, newValue: any): void;
-    private customProps;
-    resetCustomProps(): void;
-    getCustomProp(propId: string): any;
-    setCustomProp(propId: string, newValue: any): void;
+    getElementPropertyInner(node: any, propertyKeys: PropertyKeys): any;
+    getElementProperty(nodeId: string, propertyKeys: PropertyKeys): any;
+    setElementPropertyInner(node: any, propertyKeys: PropertyKeys, newValue: any): void;
+    setElementProperty(nodeId: string, propertyKeys: PropertyKeys, newValue: any): void;
+    private customProperties;
+    resetCustomProperties(): void;
+    getCustomProperty(propertyId: string): any;
+    setCustomProperty(propertyId: string, newValue: any): void;
     private customStates;
     resetCustomStates(): void;
     getCustomState(stateId: string): any;
     setCustomState(stateId: string, newValue: string): void;
-    private adaptSlotProps;
-    resetAdaptSlotProps(): void;
-    getAdaptSlotProp(propId: string): any;
-    setAdaptSlotProp(propId: string, newValue: any): void;
+    private adaptSlotProperties;
+    resetAdaptSlotProperties(): void;
+    getAdaptSlotProperty(propertyId: string): any;
+    setAdaptSlotProperty(propertyId: string, newValue: any): void;
     private interpreter;
     createInterpreter(code: string): void;
     destroyInterpreter(): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "x-runtime-lib",
   "private": false,
-  "version": "0.8.28",
+  "version": "0.8.31",
   "type": "module",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/composables/element/core/elementProp.d.ts

@@ -1,4 +0,0 @@
-import { BaseProps } from '@/types';
-export declare function useElementProp(props: BaseProps, keys: string[], json?: boolean): {
-    prop: import("vue").Ref<any, any>;
-};

package/dist/utils/prop.d.ts

@@ -1,4 +0,0 @@
-import { ZProp } from '@/types';
-export declare function getPropTag(type: string, subtype: string): string | undefined;
-export declare function getPropDefault(prop: ZProp, arrayEntry?: boolean): unknown;
-export declare function initProps(node: any, props: ZProp[]): void;