@cutos/core 3.3.1 → 4.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +368 -1266
- package/dist/cutos.cjs.js +392 -61
- package/dist/cutos.esm.js +391 -62
- package/package.json +4 -1
- package/types/index.d.ts +328 -0
package/package.json
CHANGED
|
@@ -1,9 +1,10 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@cutos/core",
|
|
3
|
-
"version": "
|
|
3
|
+
"version": "4.0.0",
|
|
4
4
|
"description": "The CUTOS (CUT Operating System) Core API is a JavaScript library that provides essential functionalities for LWA (Local Web Application) edge computing and communication in the CUTOS ecosystem. ",
|
|
5
5
|
"main": "dist/cutos.cjs.js",
|
|
6
6
|
"module": "dist/cutos.esm.js",
|
|
7
|
+
"types": "types/index.d.ts",
|
|
7
8
|
"scripts": {
|
|
8
9
|
"build:rollup": "rollup -c rollup.config.cjs"
|
|
9
10
|
},
|
|
@@ -24,6 +25,8 @@
|
|
|
24
25
|
"files": [
|
|
25
26
|
"dist/cutos.cjs.js",
|
|
26
27
|
"dist/cutos.esm.js",
|
|
28
|
+
"types/index.d.ts",
|
|
27
29
|
"package.json"
|
|
28
30
|
]
|
|
29
31
|
}
|
|
32
|
+
|
package/types/index.d.ts
ADDED
|
@@ -0,0 +1,328 @@
|
|
|
1
|
+
export type CutosCallback<T = unknown> = (result: T | null, error?: CutosError | unknown) => void;
|
|
2
|
+
|
|
3
|
+
export class CutosError extends Error {
|
|
4
|
+
constructor(code?: string, message?: string, detail?: unknown);
|
|
5
|
+
name: string;
|
|
6
|
+
code: string;
|
|
7
|
+
message: string;
|
|
8
|
+
detail?: unknown;
|
|
9
|
+
}
|
|
10
|
+
|
|
11
|
+
export interface Command<TArgs = unknown> {
|
|
12
|
+
cmd: string;
|
|
13
|
+
args?: TArgs;
|
|
14
|
+
[key: string]: unknown;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
export interface StatusResult<T = unknown> {
|
|
18
|
+
status: boolean;
|
|
19
|
+
msg: T;
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
export interface ErrorResult {
|
|
23
|
+
status: false;
|
|
24
|
+
msg: CutosError;
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
export interface DeviceInitOptions {
|
|
28
|
+
[key: string]: unknown;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
export interface DeviceStatus {
|
|
32
|
+
status?: string;
|
|
33
|
+
info?: unknown;
|
|
34
|
+
[key: string]: unknown;
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
export interface CapabilityOptions {
|
|
38
|
+
type?: string;
|
|
39
|
+
device?: Device;
|
|
40
|
+
[key: string]: unknown;
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
export interface ProviderOptions {
|
|
44
|
+
type?: string;
|
|
45
|
+
driver?: Driver;
|
|
46
|
+
counter?: number;
|
|
47
|
+
[key: string]: unknown;
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
export interface CallOptions {
|
|
51
|
+
timeout?: number;
|
|
52
|
+
[key: string]: unknown;
|
|
53
|
+
}
|
|
54
|
+
|
|
55
|
+
export interface ProviderContext<TArgs = unknown> {
|
|
56
|
+
command: Command<TArgs>;
|
|
57
|
+
provider: Provider;
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
export type Unsubscribe = () => void;
|
|
61
|
+
|
|
62
|
+
export interface DatabaseTableOptions {
|
|
63
|
+
keyName?: string;
|
|
64
|
+
keyType?: "INTEGER" | "TEXT";
|
|
65
|
+
retentionTime?: number;
|
|
66
|
+
tid?: string | number;
|
|
67
|
+
limit?: number;
|
|
68
|
+
[key: string]: unknown;
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
export interface MirrorOptions {
|
|
72
|
+
lwaName?: string;
|
|
73
|
+
[key: string]: unknown;
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
export class IPC {
|
|
77
|
+
constructor(destAddress?: string);
|
|
78
|
+
sendTo<TArgs = unknown, TResult = unknown>(
|
|
79
|
+
channel: string,
|
|
80
|
+
args?: TArgs,
|
|
81
|
+
callback?: CutosCallback<TResult>
|
|
82
|
+
): boolean;
|
|
83
|
+
call<TArgs = unknown, TResult = unknown>(
|
|
84
|
+
channel: string,
|
|
85
|
+
args?: TArgs,
|
|
86
|
+
callback: CutosCallback<TResult>
|
|
87
|
+
): boolean;
|
|
88
|
+
call<TArgs = unknown, TResult = unknown>(channel: string, args?: TArgs): Promise<TResult>;
|
|
89
|
+
sendToWithOptions<TArgs = unknown, TResult = unknown>(
|
|
90
|
+
channel: string,
|
|
91
|
+
args?: TArgs,
|
|
92
|
+
opts?: CallOptions,
|
|
93
|
+
callback?: CutosCallback<TResult>
|
|
94
|
+
): boolean;
|
|
95
|
+
callWithOptions<TArgs = unknown, TResult = unknown>(
|
|
96
|
+
channel: string,
|
|
97
|
+
args: TArgs,
|
|
98
|
+
opts: CallOptions,
|
|
99
|
+
callback: CutosCallback<TResult>
|
|
100
|
+
): boolean;
|
|
101
|
+
callWithOptions<TArgs = unknown, TResult = unknown>(
|
|
102
|
+
channel: string,
|
|
103
|
+
args?: TArgs,
|
|
104
|
+
opts?: CallOptions
|
|
105
|
+
): Promise<TResult>;
|
|
106
|
+
on<TArgs = unknown, TResult = unknown>(
|
|
107
|
+
channel: string,
|
|
108
|
+
listener: (args: TArgs, respond: (result: TResult) => void) => void
|
|
109
|
+
): Unsubscribe | undefined;
|
|
110
|
+
removeListener(channel: string, listener?: Function | null): void;
|
|
111
|
+
}
|
|
112
|
+
|
|
113
|
+
export class Notification {
|
|
114
|
+
register(listener: (data: unknown) => void): void;
|
|
115
|
+
unregister(): void;
|
|
116
|
+
emit(event: string, msg: unknown): boolean;
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
export class Logger {
|
|
120
|
+
info(remark: string, content: string, type?: string): boolean;
|
|
121
|
+
warning(remark: string, content: string, type?: string): boolean;
|
|
122
|
+
error(remark: string, content: string, type?: string): boolean;
|
|
123
|
+
debug(remark: string, content: string, type?: string): boolean;
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
export class Device {
|
|
127
|
+
constructor(name?: string, type?: string);
|
|
128
|
+
name: string;
|
|
129
|
+
type: string;
|
|
130
|
+
init<TResult = string>(callback: CutosCallback<TResult>): boolean;
|
|
131
|
+
init<TResult = string>(opts?: DeviceInitOptions | null): Promise<TResult>;
|
|
132
|
+
init<TResult = string>(opts: DeviceInitOptions | null, callback: CutosCallback<TResult>): boolean;
|
|
133
|
+
onStatus(listener: (status: DeviceStatus) => void): void;
|
|
134
|
+
getCurrentStatus(): DeviceStatus | undefined;
|
|
135
|
+
sendCommand<TArgs = unknown, TResult = unknown>(
|
|
136
|
+
command: Command<TArgs>,
|
|
137
|
+
callback: CutosCallback<TResult>
|
|
138
|
+
): boolean;
|
|
139
|
+
sendCommand<TArgs = unknown, TResult = unknown>(command: Command<TArgs>): Promise<TResult>;
|
|
140
|
+
sendCommandWithOptions<TArgs = unknown, TResult = unknown>(
|
|
141
|
+
command: Command<TArgs>,
|
|
142
|
+
opts: CallOptions,
|
|
143
|
+
callback: CutosCallback<TResult>
|
|
144
|
+
): boolean;
|
|
145
|
+
sendCommandWithOptions<TArgs = unknown, TResult = unknown>(
|
|
146
|
+
command: Command<TArgs>,
|
|
147
|
+
opts?: CallOptions
|
|
148
|
+
): Promise<TResult>;
|
|
149
|
+
onData<TData = unknown>(listener: (data: TData) => void): Unsubscribe;
|
|
150
|
+
offData(listener?: Function | null): void;
|
|
151
|
+
getCurrentData<TData = unknown>(): TData;
|
|
152
|
+
readDeviceInfo<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
153
|
+
readDeviceInfo<TResult = unknown>(): Promise<TResult>;
|
|
154
|
+
}
|
|
155
|
+
|
|
156
|
+
export class Driver {
|
|
157
|
+
constructor(name?: string, type?: string, counter?: number);
|
|
158
|
+
name: string;
|
|
159
|
+
type: string;
|
|
160
|
+
startBeat(): void;
|
|
161
|
+
updateStatusInfo(status?: string, info?: unknown): void;
|
|
162
|
+
sendData<TData = unknown>(data: TData): void;
|
|
163
|
+
sendResponse<TData = unknown>(data: TData, topic?: string): void;
|
|
164
|
+
onCommand<TArgs = unknown, TResult = unknown>(
|
|
165
|
+
listener: (command: Command<TArgs>, respond: (result: TResult) => void) => void
|
|
166
|
+
): Unsubscribe | undefined;
|
|
167
|
+
offCommand(listener?: Function | null): void;
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
export class Capability {
|
|
171
|
+
constructor(name: string, opts?: CapabilityOptions);
|
|
172
|
+
name: string;
|
|
173
|
+
type: string;
|
|
174
|
+
call<TParams = unknown, TResult = unknown>(
|
|
175
|
+
method: string,
|
|
176
|
+
params: TParams,
|
|
177
|
+
callback: CutosCallback<TResult>
|
|
178
|
+
): boolean;
|
|
179
|
+
call<TParams = unknown, TResult = unknown>(
|
|
180
|
+
method: string,
|
|
181
|
+
params?: TParams,
|
|
182
|
+
options?: CallOptions | null
|
|
183
|
+
): Promise<TResult>;
|
|
184
|
+
call<TParams = unknown, TResult = unknown>(
|
|
185
|
+
method: string,
|
|
186
|
+
params: TParams,
|
|
187
|
+
options: CallOptions | null,
|
|
188
|
+
callback: CutosCallback<TResult>
|
|
189
|
+
): boolean;
|
|
190
|
+
on<TData = unknown>(event: string, listener: (data: TData, raw: unknown) => void): Unsubscribe;
|
|
191
|
+
off(event: string, listener?: Function | null): void;
|
|
192
|
+
dispose(): boolean;
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
export class Provider {
|
|
196
|
+
constructor(name: string, opts?: ProviderOptions);
|
|
197
|
+
name: string;
|
|
198
|
+
type: string;
|
|
199
|
+
method<TParams = unknown, TResult = unknown>(
|
|
200
|
+
method: string,
|
|
201
|
+
handler: (params: TParams, context: ProviderContext<TParams>) => TResult | Promise<TResult>
|
|
202
|
+
): this;
|
|
203
|
+
emit<TData = unknown>(event: string, data: TData): boolean;
|
|
204
|
+
dispose(): boolean;
|
|
205
|
+
}
|
|
206
|
+
|
|
207
|
+
export class Database {
|
|
208
|
+
constructor(db?: string);
|
|
209
|
+
KEY_TYPE_TEXT: "TEXT";
|
|
210
|
+
KEY_TYPE_INTEGER: "INTEGER";
|
|
211
|
+
connect<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
212
|
+
connect<TResult = unknown>(): Promise<TResult>;
|
|
213
|
+
run<TResult = unknown>(sql: string, callback: CutosCallback<TResult>): boolean;
|
|
214
|
+
run<TResult = unknown>(sql: string): Promise<TResult>;
|
|
215
|
+
setupMirror(gwIPC: unknown, lwaName: string, confirm?: boolean): void;
|
|
216
|
+
static Table: typeof DatabaseTable;
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
export class DatabaseTable {
|
|
220
|
+
constructor(name: string, database: Database);
|
|
221
|
+
create<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
222
|
+
create<TResult = unknown>(opts?: DatabaseTableOptions): Promise<TResult>;
|
|
223
|
+
create<TResult = unknown>(opts: DatabaseTableOptions, callback: CutosCallback<TResult>): boolean;
|
|
224
|
+
insert<TResult = unknown>(value: unknown, callback: CutosCallback<TResult>): boolean;
|
|
225
|
+
insert<TResult = unknown>(value: unknown, opts?: DatabaseTableOptions): Promise<TResult>;
|
|
226
|
+
insert<TResult = unknown>(value: unknown, opts: DatabaseTableOptions, callback: CutosCallback<TResult>): boolean;
|
|
227
|
+
insertById<TResult = unknown>(id: string | number, value: unknown, callback: CutosCallback<TResult>): boolean;
|
|
228
|
+
insertById<TResult = unknown>(id: string | number, value: unknown, opts?: DatabaseTableOptions): Promise<TResult>;
|
|
229
|
+
insertById<TResult = unknown>(
|
|
230
|
+
id: string | number,
|
|
231
|
+
value: unknown,
|
|
232
|
+
opts: DatabaseTableOptions,
|
|
233
|
+
callback: CutosCallback<TResult>
|
|
234
|
+
): boolean;
|
|
235
|
+
insertByKey<TResult = unknown>(key: string, value: unknown, callback: CutosCallback<TResult>): boolean;
|
|
236
|
+
insertByKey<TResult = unknown>(key: string, value: unknown, opts?: DatabaseTableOptions): Promise<TResult>;
|
|
237
|
+
insertByKey<TResult = unknown>(
|
|
238
|
+
key: string,
|
|
239
|
+
value: unknown,
|
|
240
|
+
opts: DatabaseTableOptions,
|
|
241
|
+
callback: CutosCallback<TResult>
|
|
242
|
+
): boolean;
|
|
243
|
+
update<TResult = unknown>(id: string | number, value: unknown, callback: CutosCallback<TResult>): boolean;
|
|
244
|
+
update<TResult = unknown>(id: string | number, value: unknown): Promise<TResult>;
|
|
245
|
+
updateByKey<TResult = unknown>(key: string, value: unknown, callback: CutosCallback<TResult>): boolean;
|
|
246
|
+
updateByKey<TResult = unknown>(key: string, value: unknown): Promise<TResult>;
|
|
247
|
+
delete<TResult = unknown>(id: string | number, callback: CutosCallback<TResult>): boolean;
|
|
248
|
+
delete<TResult = unknown>(id: string | number): Promise<TResult>;
|
|
249
|
+
query<TResult = unknown>(id: string | number, callback: CutosCallback<TResult>): boolean;
|
|
250
|
+
query<TResult = unknown>(id: string | number): Promise<TResult>;
|
|
251
|
+
queryByKey<TResult = unknown>(key: string, callback: CutosCallback<TResult>): boolean;
|
|
252
|
+
queryByKey<TResult = unknown>(key: string): Promise<TResult>;
|
|
253
|
+
queryByTid<TResult = unknown>(tid: string | number, callback: CutosCallback<TResult>): boolean;
|
|
254
|
+
queryByTid<TResult = unknown>(tid: string | number): Promise<TResult>;
|
|
255
|
+
queryUnsynced<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
256
|
+
queryUnsynced<TResult = unknown>(opts?: DatabaseTableOptions): Promise<TResult>;
|
|
257
|
+
queryUnsynced<TResult = unknown>(opts: DatabaseTableOptions, callback: CutosCallback<TResult>): boolean;
|
|
258
|
+
queryAll<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
259
|
+
queryAll<TResult = unknown>(): Promise<TResult>;
|
|
260
|
+
sync<TResult = unknown>(id: string | number, callback: CutosCallback<TResult>): boolean;
|
|
261
|
+
sync<TResult = unknown>(id: string | number): Promise<TResult>;
|
|
262
|
+
}
|
|
263
|
+
|
|
264
|
+
export interface CoreAPI {
|
|
265
|
+
init(callback: CutosCallback<string>): boolean;
|
|
266
|
+
init(host?: string | null): Promise<string>;
|
|
267
|
+
init(host: string | null, callback: CutosCallback<string>): boolean;
|
|
268
|
+
connected(): boolean;
|
|
269
|
+
getVersion(): string;
|
|
270
|
+
getPlatform<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
271
|
+
getPlatform<TResult = unknown>(): Promise<TResult>;
|
|
272
|
+
getConfig<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
273
|
+
getConfig<TResult = unknown>(): Promise<TResult>;
|
|
274
|
+
getBoxInfo<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
275
|
+
getBoxInfo<TResult = unknown>(): Promise<TResult>;
|
|
276
|
+
getSignInfo<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
277
|
+
getSignInfo<TResult = unknown>(): Promise<TResult>;
|
|
278
|
+
getDeviceInfo<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
279
|
+
getDeviceInfo<TResult = unknown>(): Promise<TResult>;
|
|
280
|
+
getSignGroupInfo<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
281
|
+
getSignGroupInfo<TResult = unknown>(): Promise<TResult>;
|
|
282
|
+
getIPC(destAddress?: string): IPC;
|
|
283
|
+
getNotification(): Notification;
|
|
284
|
+
getLogger(): Logger;
|
|
285
|
+
shell<TResult = unknown>(command: string, callback: CutosCallback<TResult>): boolean;
|
|
286
|
+
shell<TResult = unknown>(command: string): Promise<TResult>;
|
|
287
|
+
getVolume<TResult = unknown>(callback: CutosCallback<TResult>): boolean;
|
|
288
|
+
getVolume<TResult = unknown>(): Promise<TResult>;
|
|
289
|
+
setVolume<TResult = unknown>(vol: number, callback: CutosCallback<TResult>): boolean;
|
|
290
|
+
setVolume<TResult = unknown>(vol: number): Promise<TResult>;
|
|
291
|
+
setHttpProxy<TResult = unknown>(api: string, target: string, callback: CutosCallback<TResult>): boolean;
|
|
292
|
+
setHttpProxy<TResult = unknown>(api: string, target: string): Promise<TResult>;
|
|
293
|
+
capability(name: string, opts?: CapabilityOptions): Capability;
|
|
294
|
+
provider(name: string, opts?: ProviderOptions): Provider;
|
|
295
|
+
device(name: string, opts?: CapabilityOptions): Capability;
|
|
296
|
+
driver(name: string, opts?: ProviderOptions): Provider;
|
|
297
|
+
}
|
|
298
|
+
|
|
299
|
+
export interface CoreDefine {
|
|
300
|
+
DEVICE: Record<string, string>;
|
|
301
|
+
HEARTBEAT_STATUS: Record<string, string>;
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
export interface CoreClass {
|
|
305
|
+
Device: typeof Device;
|
|
306
|
+
Driver: typeof Driver;
|
|
307
|
+
Database: typeof Database;
|
|
308
|
+
Capability: typeof Capability;
|
|
309
|
+
Provider: typeof Provider;
|
|
310
|
+
CutosError: typeof CutosError;
|
|
311
|
+
}
|
|
312
|
+
|
|
313
|
+
export interface CoreSimulator {
|
|
314
|
+
start(driver: { init(args?: unknown): void }, port?: number): void;
|
|
315
|
+
}
|
|
316
|
+
|
|
317
|
+
export const CoreAPI: CoreAPI;
|
|
318
|
+
export const CoreDefine: CoreDefine;
|
|
319
|
+
export const CoreClass: CoreClass;
|
|
320
|
+
export const cutosAPI: Record<string, unknown>;
|
|
321
|
+
export const CoreSimulator: CoreSimulator;
|
|
322
|
+
export { CutosError };
|
|
323
|
+
export const cutos: {
|
|
324
|
+
capability(name: string, opts?: CapabilityOptions): Capability;
|
|
325
|
+
provider(name: string, opts?: ProviderOptions): Provider;
|
|
326
|
+
device(name: string, opts?: CapabilityOptions): Capability;
|
|
327
|
+
driver(name: string, opts?: ProviderOptions): Provider;
|
|
328
|
+
};
|