cdp-material-sdk 0.0.5

package/dist/protocol/adapter.d.ts

@@ -0,0 +1,50 @@
+import type { CustomEventKey, EventKey, EngineEventProtocol, StandardEventKey } from './events';
+/**
+ * 作用域上下文 — 包含所在作用域数据及索引。
+ *
+ * 例如在表格行或列表项中，record 为当前行/项数据，index 为其索引。
+ */
+export interface ScopeContext {
+    record: any;
+    index?: number;
+}
+export interface StandardEventBinding<K extends StandardEventKey> {
+    propName?: string;
+    transform?: (...args: any[]) => EngineEventProtocol[K];
+    toScope?: (...args: any[]) => ScopeContext | undefined;
+}
+export interface CustomEventBinding {
+    propName?: string;
+    transform?: (...args: any[]) => unknown;
+    toScope?: (...args: any[]) => ScopeContext | undefined;
+}
+export interface EventAdapter<K extends StandardEventKey> extends StandardEventBinding<K> {
+    type: K;
+}
+export interface CustomEventAdapter extends CustomEventBinding {
+    type: CustomEventKey;
+}
+export type ComponentAdapterStandardEventMap = Partial<{
+    [K in StandardEventKey]: StandardEventBinding<K>;
+}>;
+export type ComponentAdapterCustomEventMap = Partial<Record<CustomEventKey, CustomEventBinding>>;
+export type StandardEventAdapter = {
+    [K in StandardEventKey]: EventAdapter<K>;
+}[StandardEventKey];
+export interface AdapterEventSource {
+    events?: ComponentAdapterStandardEventMap;
+    customEvents?: ComponentAdapterCustomEventMap;
+}
+export interface NormalizedAdapterEvents {
+    standard: StandardEventAdapter[];
+    custom: CustomEventAdapter[];
+    all: Array<StandardEventAdapter | CustomEventAdapter>;
+    allKeys: EventKey[];
+}
+export declare function normalizeAdapterEvents(source?: AdapterEventSource | null): NormalizedAdapterEvents;
+export interface ComponentAdapter {
+    events?: ComponentAdapterStandardEventMap;
+    customEvents?: ComponentAdapterCustomEventMap;
+    propMapping?: Record<string, string>;
+    mapProps?: (props: any) => any;
+}

package/dist/protocol/common-schemas.d.ts

@@ -0,0 +1,64 @@
+import type { FromSchema } from 'json-schema-to-ts';
+export declare const OptionItemSchema: {
+    readonly type: "object";
+    readonly properties: {
+        readonly label: {
+            readonly type: "string";
+            readonly title: "显示名称";
+        };
+        readonly value: {
+            readonly type: "string";
+            readonly title: "选项值";
+        };
+        readonly disabled: {
+            readonly type: "boolean";
+            readonly title: "是否禁用";
+        };
+    };
+};
+export declare const OptionsSchema: {
+    readonly type: "array";
+    readonly title: "选项列表";
+    readonly items: {
+        readonly type: "object";
+        readonly properties: {
+            readonly label: {
+                readonly type: "string";
+                readonly title: "显示名称";
+            };
+            readonly value: {
+                readonly type: "string";
+                readonly title: "选项值";
+            };
+            readonly disabled: {
+                readonly type: "boolean";
+                readonly title: "是否禁用";
+            };
+        };
+    };
+};
+export declare const RemoteOptionConfigSchema: {
+    readonly type: "object";
+    readonly title: "远程选项配置";
+    readonly properties: {
+        readonly panelCode: {
+            readonly type: "string";
+            readonly title: "面板代码";
+        };
+        readonly fieldName: {
+            readonly type: "string";
+            readonly title: "字段名称";
+        };
+        readonly condition: {
+            readonly type: "object";
+            readonly title: "查询条件";
+            readonly description: "声明式查询条件，支持表达式绑定。";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+        };
+    };
+};
+export type OptionItem = FromSchema<typeof OptionItemSchema>;
+export type Options = FromSchema<typeof OptionsSchema>;
+export type RemoteOptionConfig = FromSchema<typeof RemoteOptionConfigSchema>;

package/dist/protocol/events.d.ts

@@ -0,0 +1,48 @@
+import { ENGINE_EVENT_TYPE } from '../constants/event';
+export interface EngineEventProtocol {
+    [ENGINE_EVENT_TYPE.MOUNT]: void;
+    [ENGINE_EVENT_TYPE.UNMOUNT]: void;
+    [ENGINE_EVENT_TYPE.CLICK]: void;
+    [ENGINE_EVENT_TYPE.FOCUS]: void;
+    [ENGINE_EVENT_TYPE.BLUR]: void;
+    [ENGINE_EVENT_TYPE.VALUE_CHANGE]: {
+        newValue: any;
+        oldValue: any;
+    };
+    [ENGINE_EVENT_TYPE.ITEM_CLICK]: {
+        index: number;
+        item: Record<string, any>;
+    };
+    [ENGINE_EVENT_TYPE.ITEM_DOUBLE_CLICK]: {
+        index: number;
+        item: Record<string, any>;
+    };
+    [ENGINE_EVENT_TYPE.ITEM_RIGHT_CLICK]: {
+        index: number;
+        item: Record<string, any>;
+    };
+    [ENGINE_EVENT_TYPE.ITEM_LONG_PRESS]: {
+        index: number;
+        item: Record<string, any>;
+    };
+    [ENGINE_EVENT_TYPE.DATA_FETCH]: {
+        panelCode: string;
+        condition?: Record<string, any>;
+        keyword?: string;
+        pageNo?: number;
+        pageSize?: number;
+        orderBy?: Array<Record<string, unknown>>;
+        advancedConditions?: Record<string, unknown>;
+        fieldInfo?: {
+            fieldName: string;
+        };
+    };
+}
+export type StandardEventKey = keyof EngineEventProtocol;
+export type CustomEventKey = `${string}:${string}`;
+export type EventKey = StandardEventKey | CustomEventKey;
+export declare const STANDARD_EVENT_KEYS: StandardEventKey[];
+export declare function isStandardEventKey(type: string): type is StandardEventKey;
+export declare function isCustomEventKey(type: string): type is CustomEventKey;
+export type EventPayload<K extends StandardEventKey> = EngineEventProtocol[K];
+export type EngineEventHandler<K extends StandardEventKey> = EngineEventProtocol[K] extends void ? () => void : (params: EngineEventProtocol[K]) => void;

package/dist/protocol/manifest-types.d.ts

@@ -0,0 +1,10 @@
+import type { FromSchema, JSONSchema } from 'json-schema-to-ts';
+export type ManifestProps<S extends JSONSchema> = FromSchema<S>;
+export type ExtractManifestProps<M extends {
+    props?: {
+        type: 'object';
+        properties: Record<string, unknown>;
+    };
+}> = M extends {
+    props: infer S extends JSONSchema;
+} ? FromSchema<S> : Record<string, never>;

package/dist/protocol/manifest.d.ts

@@ -0,0 +1,144 @@
+import type { JSONSchema7 } from 'json-schema';
+import type { ComponentAdapter } from './adapter';
+import type { CustomEventKey, EventKey, StandardEventKey } from './events';
+import type { ComponentTrait } from './traits';
+import type { ComponentCategory } from '../types/category';
+export declare const DYNAMIC_ENUM_KEY = "x-dynamic-enum";
+export declare const SLOT_KEY = "x-slot";
+export declare const INJECT_PATH_ROOT = "$root";
+/** useImperativeHandle 中用于暴露组件运行时状态的保留 key */
+export declare const COMPONENT_STATE_KEY: "__state";
+export interface DynamicEnumConfig {
+    source: string;
+    valueKey: string;
+    labelKey: string;
+}
+export interface ExtendedJSONSchema7 extends JSONSchema7 {
+    [DYNAMIC_ENUM_KEY]?: DynamicEnumConfig;
+    [SLOT_KEY]?: boolean;
+    allowedTabs?: string[];
+    'x-editableSelectOptions'?: Array<{
+        value: string;
+        label: string;
+    }>;
+    placeholder?: string;
+}
+export interface StandardEventDeclaration {
+    title?: string;
+    description?: string;
+    deprecated?: boolean;
+}
+export interface CustomEventDeclaration extends StandardEventDeclaration {
+    payloadSchema: JSONSchema7;
+}
+export interface EventSpec extends StandardEventDeclaration {
+    type: StandardEventKey;
+}
+export interface CustomEventSpec extends CustomEventDeclaration {
+    type: CustomEventKey;
+}
+export type ManifestStandardEventMap = Partial<Record<StandardEventKey, StandardEventDeclaration>>;
+export type ManifestCustomEventMap = Partial<Record<CustomEventKey, CustomEventDeclaration>>;
+export interface ManifestEventSource {
+    events?: ManifestStandardEventMap;
+    customEvents?: ManifestCustomEventMap;
+}
+export interface NormalizedManifestEvents {
+    standard: EventSpec[];
+    custom: CustomEventSpec[];
+    all: Array<EventSpec | CustomEventSpec>;
+    allKeys: EventKey[];
+}
+export declare function normalizeManifestEvents(source?: ManifestEventSource | null): NormalizedManifestEvents;
+export interface ObjectSchema extends JSONSchema7 {
+    type: 'object';
+    properties: Record<string, ExtendedJSONSchema7>;
+}
+export interface ActionSpec {
+    title: string;
+    description?: string;
+    params?: ObjectSchema;
+    returns?: JSONSchema7;
+    ai?: {
+        scenario?: string;
+        tips?: string[];
+    };
+}
+export interface StateSpec {
+    title: string;
+    description?: string;
+    schema: JSONSchema7;
+}
+export interface AIUsageSpec {
+    tips?: string[];
+    warnings?: string[];
+}
+export declare const LOADING_STRATEGY: {
+    readonly NATIVE: "native";
+    readonly WRAPPER: "wrapper";
+    readonly NONE: "none";
+};
+export type LoadingStrategy = typeof LOADING_STRATEGY[keyof typeof LOADING_STRATEGY];
+export declare const LOADING_WRAPPER_TYPE: {
+    readonly SPIN: "spin";
+    readonly SKELETON: "skeleton";
+    readonly WAVE: "wave";
+};
+export type LoadingWrapperType = typeof LOADING_WRAPPER_TYPE[keyof typeof LOADING_WRAPPER_TYPE] | (string & {});
+export declare const LOADING_PROP_NAME = "loading";
+export interface EnginePolicies {
+    render?: {
+        injection?: {
+            rootPath?: string;
+        };
+        loading?: {
+            strategy: LoadingStrategy;
+            propName?: string;
+            wrapperType?: LoadingWrapperType;
+            wrapperProps?: Record<string, any>;
+        };
+    };
+}
+export interface SlotDefinition {
+    title: string;
+    description?: string;
+    defaultEnabled?: boolean;
+    allowedChildren?: string[];
+    scoped?: boolean;
+    scopeDescription?: string;
+    dynamic?: boolean;
+    dynamicSource?: string;
+    dynamicFilter?: string;
+    dynamicKey?: string;
+    dynamicTitle?: string;
+}
+export interface ComponentManifest {
+    type: string;
+    alias?: string[];
+    adapter?: ComponentAdapter;
+    engine?: EnginePolicies;
+    meta: {
+        title: string;
+        category: ComponentCategory;
+        valueSchema?: JSONSchema7;
+        icon?: string;
+        description?: string;
+        hiddenInComponentList?: boolean;
+        subGroup?: string;
+    };
+    traits?: ComponentTrait[];
+    nesting?: {
+        allowedChildren?: string[];
+        allowedParents?: string[];
+        maxChildren?: number;
+        minChildren?: number;
+    };
+    props?: ObjectSchema;
+    slots?: Record<string, SlotDefinition>;
+    events?: ManifestStandardEventMap;
+    customEvents?: ManifestCustomEventMap;
+    actions?: Record<string, ActionSpec>;
+    _componentActionKeys?: readonly string[];
+    state?: Record<string, StateSpec>;
+    usage?: AIUsageSpec;
+}

package/dist/protocol/traits.d.ts

@@ -0,0 +1,7 @@
+export declare const COMPONENT_TRAIT: {
+    readonly DATA_FIELD: "Data.Field";
+    readonly DATA_CONTAINER: "Data.Container";
+    readonly LAYOUT_CONTAINER: "Layout.Container";
+    readonly INTERACTION_CLICKABLE: "Interaction.Clickable";
+};
+export type ComponentTrait = typeof COMPONENT_TRAIT[keyof typeof COMPONENT_TRAIT];

package/dist/types/category.d.ts

@@ -0,0 +1,15 @@
+export declare const COMPONENT_CATEGORY: {
+    readonly GENERAL: "General";
+    readonly FLOAT: "Float";
+    readonly LAYOUT: "Layout";
+    readonly DATA_ENTRY: "DataEntry";
+    readonly DATA_DISPLAY: "DataDisplay";
+    readonly CHART: "Chart";
+    readonly BUSINESS: "Business";
+    readonly SHELL: "Shell";
+    readonly PAGE: "Page";
+    readonly DEV: "Dev";
+    readonly HTML_TEMPLATE: "HtmlTemplate";
+};
+export type ComponentCategory = typeof COMPONENT_CATEGORY[keyof typeof COMPONENT_CATEGORY];
+export declare const CATEGORY_LABELS: Record<ComponentCategory, string>;

package/dist/utils/mergeInitialValue.d.ts

@@ -0,0 +1,10 @@
+/**
+ * mergeComponentInitialValue — 组件初始值合并工具
+ *
+ * 从宿主 pageStore 移植的完整合并语义，确保 SDK 中 useDataContainer 的
+ * runtime fallback 与宿主 initComponentData 保持一致。
+ *
+ * 维护要求：任何初始值合并规则的调整都应同步到此处，
+ * 避免 SDK 侧 getContainerData()/containerData 与宿主 initComponentData 的语义漂移。
+ */
+export declare const mergeComponentInitialValue: (existingValue: unknown, initialValue: unknown) => unknown;