ngx-edyta-entity 0.2.17 → 0.2.21
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/fesm2022/ngx-edyta-entity.mjs +3427 -1881
- package/fesm2022/ngx-edyta-entity.mjs.map +1 -1
- package/package.json +15 -12
- package/types/ngx-edyta-entity.d.ts +1164 -919
- package/styles/styles.css +0 -7
|
@@ -1,1025 +1,1270 @@
|
|
|
1
|
-
import * as i0 from
|
|
2
|
-
import {
|
|
3
|
-
import { TranslateService } from
|
|
4
|
-
import { Observable } from
|
|
5
|
-
import * as i28 from
|
|
6
|
-
import { ChordKey } from
|
|
7
|
-
import { DomSanitizer, SafeHtml } from
|
|
8
|
-
import * as i25 from
|
|
9
|
-
import { Router } from
|
|
10
|
-
import * as i24 from
|
|
11
|
-
import * as i26 from
|
|
12
|
-
import * as i27 from
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
1
|
+
import * as i0 from "@angular/core";
|
|
2
|
+
import { AfterViewChecked, EventEmitter, OnDestroy } from "@angular/core";
|
|
3
|
+
import { TranslateService } from "@ngx-translate/core";
|
|
4
|
+
import { Observable } from "rxjs";
|
|
5
|
+
import * as i28 from "ngx-edyta-chords";
|
|
6
|
+
import { ChordKey } from "ngx-edyta-chords";
|
|
7
|
+
import { DomSanitizer, SafeHtml } from "@angular/platform-browser";
|
|
8
|
+
import * as i25 from "@angular/router";
|
|
9
|
+
import { Router } from "@angular/router";
|
|
10
|
+
import * as i24 from "@angular/common";
|
|
11
|
+
import * as i26 from "@angular/forms";
|
|
12
|
+
import * as i27 from "ngx-edyta-fe-elements";
|
|
13
|
+
export declare class CanvasComponent {
|
|
14
|
+
static _dependencies: {
|
|
15
|
+
EventEmitter: {
|
|
16
|
+
new (isAsync?: boolean): EventEmitter<any>;
|
|
17
|
+
new <T>(isAsync?: boolean): EventEmitter<T>;
|
|
18
|
+
readonly prototype: EventEmitter<any>;
|
|
19
|
+
};
|
|
20
|
+
};
|
|
21
|
+
private _title;
|
|
22
|
+
private _picture;
|
|
23
|
+
private _contentChange;
|
|
24
|
+
private _evaluate;
|
|
25
|
+
checkButtonText: string;
|
|
26
|
+
previousButtonText: string;
|
|
27
|
+
nextButtonText: string;
|
|
28
|
+
showBottomPane: boolean;
|
|
29
|
+
constructor();
|
|
30
|
+
get contentChange(): EventEmitter<unknown>;
|
|
31
|
+
set contentChange(value: EventEmitter<unknown>);
|
|
32
|
+
get evaluate(): EventEmitter<void>;
|
|
33
|
+
set evaluate(value: EventEmitter<void>);
|
|
34
|
+
get title(): string;
|
|
35
|
+
set title(value: string);
|
|
36
|
+
get picture(): string | null;
|
|
37
|
+
set picture(value: string | null);
|
|
38
|
+
onEvaluate(): void;
|
|
39
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<CanvasComponent, never>;
|
|
40
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<CanvasComponent, "edyta-canvas", never, {
|
|
41
|
+
"checkButtonText": {
|
|
42
|
+
"alias": "checkButtonText";
|
|
43
|
+
"required": true;
|
|
44
|
+
};
|
|
45
|
+
"previousButtonText": {
|
|
46
|
+
"alias": "previousButtonText";
|
|
47
|
+
"required": true;
|
|
48
|
+
};
|
|
49
|
+
"nextButtonText": {
|
|
50
|
+
"alias": "nextButtonText";
|
|
51
|
+
"required": true;
|
|
52
|
+
};
|
|
53
|
+
"showBottomPane": {
|
|
54
|
+
"alias": "showBottomPane";
|
|
55
|
+
"required": false;
|
|
56
|
+
};
|
|
57
|
+
"title": {
|
|
58
|
+
"alias": "title";
|
|
59
|
+
"required": false;
|
|
60
|
+
};
|
|
61
|
+
"picture": {
|
|
62
|
+
"alias": "picture";
|
|
63
|
+
"required": false;
|
|
64
|
+
};
|
|
65
|
+
}, {
|
|
66
|
+
"contentChange": "contentChange";
|
|
67
|
+
"evaluate": "evaluate";
|
|
68
|
+
}, never, ["[breadcrumb]", "[control-panel]", "*"], false, never>;
|
|
42
69
|
}
|
|
43
|
-
|
|
44
70
|
interface LanguageService {
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
71
|
+
getDefault(): string;
|
|
72
|
+
get(): string;
|
|
73
|
+
set(language: string): void;
|
|
74
|
+
remove(): void;
|
|
75
|
+
supportedLanguages(): string[];
|
|
50
76
|
}
|
|
51
77
|
interface NotificationService {
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
78
|
+
info(message: string): void;
|
|
79
|
+
success(message: string): void;
|
|
80
|
+
warning(message: string): void;
|
|
81
|
+
error(message: string): void;
|
|
56
82
|
}
|
|
57
83
|
interface CentralService {
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
84
|
+
getLanguageService(): LanguageService;
|
|
85
|
+
getNotificationService(): NotificationService;
|
|
86
|
+
getTranslateService(): TranslateService;
|
|
61
87
|
}
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
deleteProgress(): Observable<void>;
|
|
88
|
+
export interface InteractiveLearningEntity extends LearningEntity {
|
|
89
|
+
get progress(): unknown;
|
|
90
|
+
set progress(progress: unknown);
|
|
91
|
+
updateProgress(): Observable<unknown>;
|
|
92
|
+
deleteProgress(): Observable<void>;
|
|
68
93
|
}
|
|
69
|
-
declare abstract class InteractiveLearningEntityBase extends LearningEntityBase implements InteractiveLearningEntity {
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
94
|
+
export declare abstract class InteractiveLearningEntityBase extends LearningEntityBase implements InteractiveLearningEntity {
|
|
95
|
+
abstract get progress(): unknown;
|
|
96
|
+
abstract set progress(progress: unknown);
|
|
97
|
+
updateProgress(): Observable<unknown>;
|
|
98
|
+
deleteProgress(): Observable<void>;
|
|
74
99
|
}
|
|
75
|
-
|
|
76
100
|
interface LearningEntityProgressService {
|
|
77
|
-
|
|
78
|
-
|
|
101
|
+
update(entity: InteractiveLearningEntity): Observable<unknown>;
|
|
102
|
+
delete(entity: InteractiveLearningEntity): Observable<void>;
|
|
79
103
|
}
|
|
80
|
-
|
|
81
|
-
|
|
104
|
+
export type Entity = {
|
|
105
|
+
id: number;
|
|
106
|
+
title: string;
|
|
107
|
+
type: {
|
|
82
108
|
id: number;
|
|
109
|
+
key: string;
|
|
83
110
|
title: string;
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
picture: string | null;
|
|
102
|
-
content?: unknown;
|
|
103
|
-
result?: unknown | null;
|
|
104
|
-
progress?: unknown | null;
|
|
111
|
+
description?: string | null;
|
|
112
|
+
};
|
|
113
|
+
version?: {
|
|
114
|
+
id: number;
|
|
115
|
+
isActive: boolean;
|
|
116
|
+
};
|
|
117
|
+
organization?: {
|
|
118
|
+
id: number;
|
|
119
|
+
key: string;
|
|
120
|
+
};
|
|
121
|
+
level: {
|
|
122
|
+
id: number;
|
|
123
|
+
};
|
|
124
|
+
picture: string | null;
|
|
125
|
+
content?: unknown;
|
|
126
|
+
result?: unknown | null;
|
|
127
|
+
progress?: unknown | null;
|
|
105
128
|
};
|
|
106
|
-
type Evaluation = {
|
|
107
|
-
|
|
129
|
+
export type Evaluation = {
|
|
130
|
+
correct: boolean;
|
|
108
131
|
};
|
|
109
|
-
interface LearningEntityService {
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
132
|
+
export interface LearningEntityService {
|
|
133
|
+
get(organizationKey: string, levelId: number, id: number): Observable<LearningEntity>;
|
|
134
|
+
getAll(organizationKey: string, levelId: number): Observable<LearningEntity[]>;
|
|
135
|
+
evaluate(entity: InteractiveLearningEntity): Observable<Evaluation>;
|
|
136
|
+
getProgressService(): LearningEntityProgressService;
|
|
137
|
+
setProgressService(service: LearningEntityProgressService): void;
|
|
115
138
|
}
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
Full = "full"
|
|
139
|
+
export declare enum EntityAccess {
|
|
140
|
+
Preview = "preview",
|
|
141
|
+
Full = "full"
|
|
120
142
|
}
|
|
121
|
-
type LearningEntityAssignment = {
|
|
122
|
-
|
|
123
|
-
|
|
143
|
+
export type LearningEntityAssignment = {
|
|
144
|
+
readonly organizationKey: string;
|
|
145
|
+
readonly levelId: number;
|
|
124
146
|
};
|
|
125
|
-
type LearningEntityDescription = {
|
|
126
|
-
|
|
127
|
-
|
|
147
|
+
export type LearningEntityDescription = {
|
|
148
|
+
short: string | null;
|
|
149
|
+
full: string | null;
|
|
128
150
|
};
|
|
129
|
-
type LearningEntityCommon = {
|
|
151
|
+
export type LearningEntityCommon = {
|
|
152
|
+
id: number;
|
|
153
|
+
title: string;
|
|
154
|
+
description: LearningEntityDescription;
|
|
155
|
+
type: {
|
|
130
156
|
id: number;
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
picture: string | null;
|
|
144
|
-
previous: NextPreviousResult | null;
|
|
145
|
-
next: NextPreviousResult | null;
|
|
146
|
-
access: EntityAccess;
|
|
157
|
+
key: string;
|
|
158
|
+
};
|
|
159
|
+
organization: {
|
|
160
|
+
key: string;
|
|
161
|
+
};
|
|
162
|
+
level: {
|
|
163
|
+
id: number;
|
|
164
|
+
};
|
|
165
|
+
picture: string | null;
|
|
166
|
+
previous: NextPreviousResult | null;
|
|
167
|
+
next: NextPreviousResult | null;
|
|
168
|
+
access: EntityAccess;
|
|
147
169
|
};
|
|
148
|
-
type NextPreviousResult = {
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
170
|
+
export type NextPreviousResult = {
|
|
171
|
+
level: {
|
|
172
|
+
id: number;
|
|
173
|
+
title: string;
|
|
174
|
+
isRoot: boolean;
|
|
175
|
+
};
|
|
176
|
+
entity: {
|
|
177
|
+
id: number;
|
|
178
|
+
title: string;
|
|
179
|
+
} | null;
|
|
158
180
|
};
|
|
159
|
-
interface LearningEntity {
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
181
|
+
export interface LearningEntity {
|
|
182
|
+
get id(): number;
|
|
183
|
+
get title(): string;
|
|
184
|
+
get description(): LearningEntityDescription;
|
|
185
|
+
get type(): string;
|
|
186
|
+
get levelId(): number;
|
|
187
|
+
get organizationKey(): string;
|
|
188
|
+
get assignment(): LearningEntityAssignment;
|
|
189
|
+
get picture(): string | null;
|
|
190
|
+
get icon(): string;
|
|
191
|
+
get previous(): NextPreviousResult | null;
|
|
192
|
+
get next(): NextPreviousResult | null;
|
|
193
|
+
get access(): EntityAccess;
|
|
194
|
+
getCentralService(): CentralService;
|
|
195
|
+
setCentralService(service: CentralService): void;
|
|
196
|
+
getLearningEntityService(): LearningEntityService;
|
|
197
|
+
setLearningEntityService(service: LearningEntityService): void;
|
|
198
|
+
get content(): unknown;
|
|
199
|
+
isCheckable(): boolean;
|
|
178
200
|
}
|
|
179
|
-
declare abstract class LearningEntityBase implements LearningEntity {
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
|
|
191
|
-
|
|
192
|
-
|
|
193
|
-
|
|
194
|
-
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
201
|
+
export declare abstract class LearningEntityBase implements LearningEntity {
|
|
202
|
+
private _id;
|
|
203
|
+
private _title;
|
|
204
|
+
private _description;
|
|
205
|
+
private _type;
|
|
206
|
+
private _levelId;
|
|
207
|
+
private _organizationKey;
|
|
208
|
+
private _picture;
|
|
209
|
+
private _assignment;
|
|
210
|
+
private _previous;
|
|
211
|
+
private _next;
|
|
212
|
+
private _access;
|
|
213
|
+
private _centralService;
|
|
214
|
+
private _learningEntityService;
|
|
215
|
+
constructor(entity: LearningEntityCommon, centralService: CentralService, learningEntityService: LearningEntityService);
|
|
216
|
+
get id(): number;
|
|
217
|
+
get title(): string;
|
|
218
|
+
get description(): LearningEntityDescription;
|
|
219
|
+
get type(): string;
|
|
220
|
+
get levelId(): number;
|
|
221
|
+
get organizationKey(): string;
|
|
222
|
+
get assignment(): LearningEntityAssignment;
|
|
223
|
+
get picture(): string | null;
|
|
224
|
+
get previous(): NextPreviousResult | null;
|
|
225
|
+
get next(): NextPreviousResult | null;
|
|
226
|
+
get access(): EntityAccess;
|
|
227
|
+
getCentralService(): CentralService;
|
|
228
|
+
setCentralService(service: CentralService): void;
|
|
229
|
+
getLearningEntityService(): LearningEntityService;
|
|
230
|
+
setLearningEntityService(service: LearningEntityService): void;
|
|
231
|
+
abstract isCheckable(): boolean;
|
|
232
|
+
abstract get content(): unknown;
|
|
233
|
+
abstract get icon(): string;
|
|
234
|
+
protected abstract _init(entity: LearningEntityCommon): void;
|
|
213
235
|
}
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
|
|
220
|
-
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
|
|
236
|
+
export declare class EntityBottomPaneComponent {
|
|
237
|
+
private _entity;
|
|
238
|
+
private _evaluate;
|
|
239
|
+
checkButtonText: string;
|
|
240
|
+
previousButtonText: string;
|
|
241
|
+
nextButtonText: string;
|
|
242
|
+
constructor();
|
|
243
|
+
get entity(): LearningEntity;
|
|
244
|
+
set entity(entity: LearningEntity);
|
|
245
|
+
get evaluate(): EventEmitter<void>;
|
|
246
|
+
set evaluate(value: EventEmitter<void>);
|
|
247
|
+
onEvaluate(): void;
|
|
248
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<EntityBottomPaneComponent, never>;
|
|
249
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<EntityBottomPaneComponent, "edyta-entity-bottom-pane", never, {
|
|
250
|
+
"checkButtonText": {
|
|
251
|
+
"alias": "checkButtonText";
|
|
252
|
+
"required": true;
|
|
253
|
+
};
|
|
254
|
+
"previousButtonText": {
|
|
255
|
+
"alias": "previousButtonText";
|
|
256
|
+
"required": true;
|
|
257
|
+
};
|
|
258
|
+
"nextButtonText": {
|
|
259
|
+
"alias": "nextButtonText";
|
|
260
|
+
"required": true;
|
|
261
|
+
};
|
|
262
|
+
"entity": {
|
|
263
|
+
"alias": "entity";
|
|
264
|
+
"required": true;
|
|
265
|
+
};
|
|
266
|
+
}, {
|
|
267
|
+
"evaluate": "evaluate";
|
|
268
|
+
}, never, never, false, never>;
|
|
229
269
|
}
|
|
230
|
-
|
|
231
270
|
type StateItem = {
|
|
232
|
-
|
|
233
|
-
|
|
271
|
+
factId: string;
|
|
272
|
+
optionId: string;
|
|
234
273
|
};
|
|
235
274
|
declare namespace Puzzle {
|
|
236
|
-
|
|
237
|
-
|
|
238
|
-
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
275
|
+
type Color = {
|
|
276
|
+
requested: {
|
|
277
|
+
background: boolean;
|
|
278
|
+
text: boolean;
|
|
279
|
+
};
|
|
280
|
+
background: string;
|
|
281
|
+
text: string;
|
|
282
|
+
};
|
|
283
|
+
type Item = {
|
|
284
|
+
text: string;
|
|
285
|
+
id: string;
|
|
286
|
+
color: Color;
|
|
287
|
+
};
|
|
288
|
+
type FactItem = Item & {
|
|
289
|
+
assignedOptions: Item[];
|
|
290
|
+
};
|
|
291
|
+
type Set = {
|
|
292
|
+
description?: string;
|
|
293
|
+
facts: FactItem[];
|
|
294
|
+
options: Item[];
|
|
295
|
+
};
|
|
296
|
+
type State = StateItem;
|
|
297
|
+
type ValidationRule = State & {
|
|
298
|
+
mandatory: boolean;
|
|
299
|
+
};
|
|
300
|
+
}
|
|
301
|
+
declare namespace Original {
|
|
302
|
+
namespace Puzzle {
|
|
303
|
+
export type Color = {
|
|
304
|
+
requested: {
|
|
305
|
+
background: boolean;
|
|
306
|
+
text: boolean;
|
|
307
|
+
};
|
|
308
|
+
background: string;
|
|
309
|
+
text: string;
|
|
243
310
|
};
|
|
244
311
|
type Item = {
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
312
|
+
id: string;
|
|
313
|
+
text: string;
|
|
314
|
+
color?: Color;
|
|
248
315
|
};
|
|
249
|
-
type
|
|
250
|
-
|
|
316
|
+
type ResultItem = {
|
|
317
|
+
front: string;
|
|
318
|
+
back: string;
|
|
251
319
|
};
|
|
252
|
-
type
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
320
|
+
export type Result = {
|
|
321
|
+
correct: ResultItem[];
|
|
322
|
+
optional: ResultItem[];
|
|
323
|
+
} | null;
|
|
324
|
+
export type Content = {
|
|
325
|
+
type: string;
|
|
326
|
+
title: string;
|
|
327
|
+
description?: string;
|
|
328
|
+
lang: string;
|
|
329
|
+
shuffle?: boolean;
|
|
330
|
+
shuffleAll?: boolean;
|
|
331
|
+
input: {
|
|
332
|
+
front: Item[];
|
|
333
|
+
back: Item[];
|
|
334
|
+
};
|
|
256
335
|
};
|
|
257
|
-
type
|
|
258
|
-
type
|
|
259
|
-
|
|
336
|
+
export type ProgressItem = StateItem;
|
|
337
|
+
export type Progress = ProgressItem[] | null | undefined;
|
|
338
|
+
export type Set = LearningEntityCommon & {
|
|
339
|
+
content: Content;
|
|
340
|
+
progress: Progress;
|
|
260
341
|
};
|
|
342
|
+
export {};
|
|
343
|
+
}
|
|
261
344
|
}
|
|
262
|
-
declare namespace Original {
|
|
263
|
-
namespace Puzzle {
|
|
264
|
-
export type Color = {
|
|
265
|
-
requested: {
|
|
266
|
-
background: boolean;
|
|
267
|
-
text: boolean;
|
|
268
|
-
};
|
|
269
|
-
background: string;
|
|
270
|
-
text: string;
|
|
271
|
-
};
|
|
272
|
-
type Item = {
|
|
273
|
-
id: string;
|
|
274
|
-
text: string;
|
|
275
|
-
color?: Color;
|
|
276
|
-
};
|
|
277
|
-
type ResultItem = {
|
|
278
|
-
front: string;
|
|
279
|
-
back: string;
|
|
280
|
-
};
|
|
281
|
-
export type Result = {
|
|
282
|
-
correct: ResultItem[];
|
|
283
|
-
optional: ResultItem[];
|
|
284
|
-
} | null;
|
|
285
|
-
export type Content = {
|
|
286
|
-
type: string;
|
|
287
|
-
title: string;
|
|
288
|
-
description?: string;
|
|
289
|
-
lang: string;
|
|
290
|
-
shuffle?: boolean;
|
|
291
|
-
shuffleAll?: boolean;
|
|
292
|
-
input: {
|
|
293
|
-
front: Item[];
|
|
294
|
-
back: Item[];
|
|
295
|
-
};
|
|
296
|
-
};
|
|
297
|
-
export type ProgressItem = StateItem;
|
|
298
|
-
export type Progress = ProgressItem[] | null | undefined;
|
|
299
|
-
export type Set = LearningEntityCommon & {
|
|
300
|
-
content: Content;
|
|
301
|
-
progress: Progress;
|
|
302
|
-
};
|
|
303
|
-
export {};
|
|
304
|
-
}
|
|
305
|
-
}
|
|
306
|
-
|
|
307
345
|
declare abstract class PuzzleOptionDialogBaseComponent {
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
346
|
+
private _factSelected;
|
|
347
|
+
private _back2OptionsSection;
|
|
348
|
+
constructor();
|
|
349
|
+
get factSelected(): EventEmitter<Puzzle.State>;
|
|
350
|
+
set factSelected(value: EventEmitter<Puzzle.State>);
|
|
351
|
+
get back2OptionsSection(): EventEmitter<string>;
|
|
352
|
+
set back2OptionsSection(value: EventEmitter<string>);
|
|
353
|
+
onFactSelected(stateItem: Puzzle.State): void;
|
|
354
|
+
onBack2OptionsSection(optionId: string): void;
|
|
355
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleOptionDialogBaseComponent, never>;
|
|
356
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleOptionDialogBaseComponent, "ng-component", never, {}, {
|
|
357
|
+
"factSelected": "factSelected";
|
|
358
|
+
"back2OptionsSection": "back2OptionsSection";
|
|
359
|
+
}, never, never, false, never>;
|
|
319
360
|
}
|
|
320
|
-
|
|
321
361
|
declare abstract class PuzzleDropTargetComponent extends PuzzleOptionDialogBaseComponent {
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
362
|
+
static _dependencies: {
|
|
363
|
+
EventEmitter: {
|
|
364
|
+
new (isAsync?: boolean): EventEmitter<any>;
|
|
365
|
+
new <T>(isAsync?: boolean): EventEmitter<T>;
|
|
366
|
+
readonly prototype: EventEmitter<any>;
|
|
367
|
+
};
|
|
368
|
+
};
|
|
369
|
+
private _dragTargetActive;
|
|
370
|
+
private _dropped;
|
|
371
|
+
constructor();
|
|
372
|
+
get dragTargetActive(): boolean;
|
|
373
|
+
set dragTargetActive(value: boolean);
|
|
374
|
+
get dropped(): EventEmitter<string>;
|
|
375
|
+
onDrop(event: DragEvent): void;
|
|
376
|
+
onDragEnter(event: DragEvent): void;
|
|
377
|
+
onDragOver(event: DragEvent): void;
|
|
378
|
+
onDragLeave(event: DragEvent): void;
|
|
379
|
+
protected _emitDrop(id: string): void;
|
|
380
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleDropTargetComponent, never>;
|
|
381
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleDropTargetComponent, "ng-component", never, {
|
|
382
|
+
"dragTargetActive": {
|
|
383
|
+
"alias": "dragTargetActive";
|
|
384
|
+
"required": false;
|
|
385
|
+
};
|
|
386
|
+
}, {
|
|
387
|
+
"dropped": "dropped";
|
|
388
|
+
}, never, never, false, never>;
|
|
342
389
|
}
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
protected _init(entity: Original.Puzzle.Set): void;
|
|
390
|
+
export declare class PuzzleLearningEntity extends InteractiveLearningEntityBase {
|
|
391
|
+
private _content;
|
|
392
|
+
private _progress;
|
|
393
|
+
get icon(): string;
|
|
394
|
+
isCheckable(): boolean;
|
|
395
|
+
get progress(): Original.Puzzle.Progress;
|
|
396
|
+
set progress(progress: Original.Puzzle.Progress);
|
|
397
|
+
get content(): Puzzle.Set;
|
|
398
|
+
protected _init(entity: Original.Puzzle.Set): void;
|
|
353
399
|
}
|
|
354
|
-
|
|
355
400
|
declare abstract class PuzzleBaseComponent extends PuzzleOptionDialogBaseComponent {
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
401
|
+
private _entity;
|
|
402
|
+
private _text;
|
|
403
|
+
private _id;
|
|
404
|
+
private _color;
|
|
405
|
+
get entity(): PuzzleLearningEntity;
|
|
406
|
+
set entity(entity: PuzzleLearningEntity);
|
|
407
|
+
get text(): string;
|
|
408
|
+
set text(value: string);
|
|
409
|
+
get id(): string;
|
|
410
|
+
set id(value: string);
|
|
411
|
+
get color(): Puzzle.Color;
|
|
412
|
+
set color(value: Puzzle.Color);
|
|
413
|
+
getTextColor(color: Puzzle.Color): string | undefined;
|
|
414
|
+
getBackgroundColor(color: Puzzle.Color): string | undefined;
|
|
415
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleBaseComponent, never>;
|
|
416
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleBaseComponent, "ng-component", never, {
|
|
417
|
+
"entity": {
|
|
418
|
+
"alias": "entity";
|
|
419
|
+
"required": true;
|
|
420
|
+
};
|
|
421
|
+
"text": {
|
|
422
|
+
"alias": "text";
|
|
423
|
+
"required": true;
|
|
424
|
+
};
|
|
425
|
+
"id": {
|
|
426
|
+
"alias": "id";
|
|
427
|
+
"required": true;
|
|
428
|
+
};
|
|
429
|
+
"color": {
|
|
430
|
+
"alias": "color";
|
|
431
|
+
"required": true;
|
|
432
|
+
};
|
|
433
|
+
}, {}, never, never, false, never>;
|
|
372
434
|
}
|
|
373
|
-
|
|
374
435
|
type PuzzleDrop = {
|
|
375
|
-
|
|
376
|
-
|
|
436
|
+
factId: string | undefined;
|
|
437
|
+
optionId: string;
|
|
377
438
|
};
|
|
378
439
|
declare class PuzzleFactComponent extends PuzzleBaseComponent {
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
|
|
402
|
-
|
|
403
|
-
|
|
440
|
+
static _dependencies: {
|
|
441
|
+
EventEmitter: {
|
|
442
|
+
new (isAsync?: boolean): EventEmitter<any>;
|
|
443
|
+
new <T>(isAsync?: boolean): EventEmitter<T>;
|
|
444
|
+
readonly prototype: EventEmitter<any>;
|
|
445
|
+
};
|
|
446
|
+
};
|
|
447
|
+
private _dropTargetActive;
|
|
448
|
+
private _assignedOptions;
|
|
449
|
+
private _dropped;
|
|
450
|
+
private _dragged;
|
|
451
|
+
assignButtonText: string;
|
|
452
|
+
back2OptionSelectionButtonText: string;
|
|
453
|
+
constructor();
|
|
454
|
+
get dropTargetActive(): boolean;
|
|
455
|
+
set dropTargetActive(value: boolean);
|
|
456
|
+
get assignedOptions(): Puzzle.Item[];
|
|
457
|
+
set assignedOptions(value: Puzzle.Item[]);
|
|
458
|
+
get dropped(): EventEmitter<PuzzleDrop>;
|
|
459
|
+
get dragged(): EventEmitter<boolean>;
|
|
460
|
+
set dragged(value: EventEmitter<boolean>);
|
|
461
|
+
onDropped(id: string): void;
|
|
462
|
+
onDragged(isDragged: boolean): void;
|
|
463
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleFactComponent, never>;
|
|
464
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleFactComponent, "edyta-puzzle-fact", never, {
|
|
465
|
+
"assignButtonText": {
|
|
466
|
+
"alias": "assignButtonText";
|
|
467
|
+
"required": true;
|
|
468
|
+
};
|
|
469
|
+
"back2OptionSelectionButtonText": {
|
|
470
|
+
"alias": "back2OptionSelectionButtonText";
|
|
471
|
+
"required": true;
|
|
472
|
+
};
|
|
473
|
+
"dropTargetActive": {
|
|
474
|
+
"alias": "dropTargetActive";
|
|
475
|
+
"required": false;
|
|
476
|
+
};
|
|
477
|
+
"assignedOptions": {
|
|
478
|
+
"alias": "assignedOptions";
|
|
479
|
+
"required": false;
|
|
480
|
+
};
|
|
481
|
+
}, {
|
|
482
|
+
"dropped": "dropped";
|
|
483
|
+
"dragged": "dragged";
|
|
484
|
+
}, never, never, false, never>;
|
|
404
485
|
}
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
486
|
+
export declare class PuzzleComponent extends PuzzleDropTargetComponent {
|
|
487
|
+
private _entity;
|
|
488
|
+
private _puzzles;
|
|
489
|
+
private _puzzlesOriginal;
|
|
490
|
+
private _state;
|
|
491
|
+
private _dropTargetActive;
|
|
492
|
+
private _contentChange;
|
|
493
|
+
private _evaluate;
|
|
494
|
+
assignButtonText: string;
|
|
495
|
+
back2OptionSelectionButtonText: string;
|
|
496
|
+
checkButtonText: string;
|
|
497
|
+
previousButtonText: string;
|
|
498
|
+
nextButtonText: string;
|
|
499
|
+
showBottomPane: boolean;
|
|
500
|
+
constructor();
|
|
501
|
+
get entity(): PuzzleLearningEntity;
|
|
502
|
+
set entity(entity: PuzzleLearningEntity);
|
|
503
|
+
get puzzles(): Puzzle.Set;
|
|
504
|
+
set puzzles(puzzles: Puzzle.Set);
|
|
505
|
+
get dropTargetActive(): boolean;
|
|
506
|
+
set dropTargetActive(value: boolean);
|
|
507
|
+
get contentChange(): EventEmitter<unknown>;
|
|
508
|
+
set contentChange(value: EventEmitter<unknown>);
|
|
509
|
+
get evaluate(): EventEmitter<void>;
|
|
510
|
+
set evaluate(value: EventEmitter<void>);
|
|
511
|
+
onDropped(puzzleDrop: PuzzleDrop): void;
|
|
512
|
+
onDragged(isDragged: boolean): void;
|
|
513
|
+
onFactSelected(stateItem: Puzzle.State): void;
|
|
514
|
+
onBack2OptionsSection(optionId: string): void;
|
|
515
|
+
onEvaluate(): void;
|
|
516
|
+
private _process;
|
|
517
|
+
private _applyProgress;
|
|
518
|
+
protected _emitDrop(id: string): void;
|
|
519
|
+
private _buildProgressSnapshot;
|
|
520
|
+
private _stateChanged;
|
|
521
|
+
private _recalculateState;
|
|
522
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleComponent, never>;
|
|
523
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleComponent, "edyta-puzzle", never, {
|
|
524
|
+
"assignButtonText": {
|
|
525
|
+
"alias": "assignButtonText";
|
|
526
|
+
"required": true;
|
|
527
|
+
};
|
|
528
|
+
"back2OptionSelectionButtonText": {
|
|
529
|
+
"alias": "back2OptionSelectionButtonText";
|
|
530
|
+
"required": true;
|
|
531
|
+
};
|
|
532
|
+
"checkButtonText": {
|
|
533
|
+
"alias": "checkButtonText";
|
|
534
|
+
"required": true;
|
|
535
|
+
};
|
|
536
|
+
"previousButtonText": {
|
|
537
|
+
"alias": "previousButtonText";
|
|
538
|
+
"required": true;
|
|
539
|
+
};
|
|
540
|
+
"nextButtonText": {
|
|
541
|
+
"alias": "nextButtonText";
|
|
542
|
+
"required": true;
|
|
543
|
+
};
|
|
544
|
+
"showBottomPane": {
|
|
545
|
+
"alias": "showBottomPane";
|
|
546
|
+
"required": false;
|
|
547
|
+
};
|
|
548
|
+
"entity": {
|
|
549
|
+
"alias": "entity";
|
|
550
|
+
"required": true;
|
|
551
|
+
};
|
|
552
|
+
}, {
|
|
553
|
+
"contentChange": "contentChange";
|
|
554
|
+
"evaluate": "evaluate";
|
|
555
|
+
}, never, never, false, never>;
|
|
444
556
|
}
|
|
445
|
-
|
|
446
557
|
declare class PuzzleTargetComponent extends PuzzleDropTargetComponent {
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
558
|
+
private _entity;
|
|
559
|
+
private _text;
|
|
560
|
+
private _id;
|
|
561
|
+
private _dropTargetActive;
|
|
562
|
+
private _assignedOptions;
|
|
563
|
+
private _dragged;
|
|
564
|
+
assignButtonText: string;
|
|
565
|
+
back2OptionSelectionButtonText: string;
|
|
566
|
+
constructor();
|
|
567
|
+
get entity(): PuzzleLearningEntity;
|
|
568
|
+
set entity(entity: PuzzleLearningEntity);
|
|
569
|
+
get text(): string;
|
|
570
|
+
set text(value: string);
|
|
571
|
+
get id(): string;
|
|
572
|
+
set id(value: string);
|
|
573
|
+
get dropTargetActive(): boolean;
|
|
574
|
+
set dropTargetActive(value: boolean);
|
|
575
|
+
get assignedOptions(): Puzzle.Item[];
|
|
576
|
+
set assignedOptions(value: Puzzle.Item[]);
|
|
577
|
+
get dragged(): EventEmitter<boolean>;
|
|
578
|
+
set dragged(value: EventEmitter<boolean>);
|
|
579
|
+
onDragged(isDragged: boolean): void;
|
|
580
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleTargetComponent, never>;
|
|
581
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleTargetComponent, "edyta-puzzle-target", never, {
|
|
582
|
+
"assignButtonText": {
|
|
583
|
+
"alias": "assignButtonText";
|
|
584
|
+
"required": true;
|
|
585
|
+
};
|
|
586
|
+
"back2OptionSelectionButtonText": {
|
|
587
|
+
"alias": "back2OptionSelectionButtonText";
|
|
588
|
+
"required": true;
|
|
589
|
+
};
|
|
590
|
+
"entity": {
|
|
591
|
+
"alias": "entity";
|
|
592
|
+
"required": true;
|
|
593
|
+
};
|
|
594
|
+
"text": {
|
|
595
|
+
"alias": "text";
|
|
596
|
+
"required": false;
|
|
597
|
+
};
|
|
598
|
+
"id": {
|
|
599
|
+
"alias": "id";
|
|
600
|
+
"required": false;
|
|
601
|
+
};
|
|
602
|
+
"dropTargetActive": {
|
|
603
|
+
"alias": "dropTargetActive";
|
|
604
|
+
"required": false;
|
|
605
|
+
};
|
|
606
|
+
"assignedOptions": {
|
|
607
|
+
"alias": "assignedOptions";
|
|
608
|
+
"required": false;
|
|
609
|
+
};
|
|
610
|
+
}, {
|
|
611
|
+
"dragged": "dragged";
|
|
612
|
+
}, never, never, false, never>;
|
|
471
613
|
}
|
|
472
|
-
|
|
473
614
|
declare class PuzzleOptionComponent extends PuzzleBaseComponent {
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
477
|
-
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
|
|
481
|
-
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
615
|
+
static _dependencies: {
|
|
616
|
+
EventEmitter: {
|
|
617
|
+
new (isAsync?: boolean): EventEmitter<any>;
|
|
618
|
+
new <T>(isAsync?: boolean): EventEmitter<T>;
|
|
619
|
+
readonly prototype: EventEmitter<any>;
|
|
620
|
+
};
|
|
621
|
+
};
|
|
622
|
+
assignButtonText: string;
|
|
623
|
+
back2OptionSelectionButtonText: string;
|
|
624
|
+
private _back2OptionsSectionMode;
|
|
625
|
+
private _dragIsActive;
|
|
626
|
+
private _dragged;
|
|
627
|
+
constructor();
|
|
628
|
+
get back2OptionsSectionMode(): boolean;
|
|
629
|
+
set back2OptionsSectionMode(value: boolean);
|
|
630
|
+
get dragIsActive(): boolean;
|
|
631
|
+
set dragIsActive(value: boolean);
|
|
632
|
+
get dragged(): EventEmitter<boolean>;
|
|
633
|
+
onDragStart(event: DragEvent): void;
|
|
634
|
+
onDragEnd(): void;
|
|
635
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleOptionComponent, never>;
|
|
636
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleOptionComponent, "edyta-puzzle-option", never, {
|
|
637
|
+
"assignButtonText": {
|
|
638
|
+
"alias": "assignButtonText";
|
|
639
|
+
"required": true;
|
|
640
|
+
};
|
|
641
|
+
"back2OptionSelectionButtonText": {
|
|
642
|
+
"alias": "back2OptionSelectionButtonText";
|
|
643
|
+
"required": true;
|
|
644
|
+
};
|
|
645
|
+
"back2OptionsSectionMode": {
|
|
646
|
+
"alias": "back2OptionsSectionMode";
|
|
647
|
+
"required": false;
|
|
648
|
+
};
|
|
649
|
+
}, {
|
|
650
|
+
"dragged": "dragged";
|
|
651
|
+
}, never, never, false, never>;
|
|
496
652
|
}
|
|
497
|
-
|
|
498
653
|
declare class PuzzleOptionDialogComponent extends PuzzleOptionDialogBaseComponent {
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
513
|
-
|
|
514
|
-
|
|
515
|
-
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
|
|
654
|
+
private _entity;
|
|
655
|
+
private _text;
|
|
656
|
+
private _id;
|
|
657
|
+
private _selectedFactId;
|
|
658
|
+
private _back2OptionsSectionMode;
|
|
659
|
+
assignButtonText: string;
|
|
660
|
+
back2OptionSelectionButtonText: string;
|
|
661
|
+
get entity(): PuzzleLearningEntity;
|
|
662
|
+
set entity(entity: PuzzleLearningEntity);
|
|
663
|
+
get text(): string;
|
|
664
|
+
set text(value: string);
|
|
665
|
+
get id(): string;
|
|
666
|
+
set id(value: string);
|
|
667
|
+
get back2OptionsSectionMode(): boolean;
|
|
668
|
+
set back2OptionsSectionMode(value: boolean);
|
|
669
|
+
get selectedFactId(): string;
|
|
670
|
+
set selectedFactId(value: string);
|
|
671
|
+
onFactSelected(): void;
|
|
672
|
+
onBack2OptionsSection(): void;
|
|
673
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleOptionDialogComponent, never>;
|
|
674
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleOptionDialogComponent, "[edyta-puzzle-option-dialog]", never, {
|
|
675
|
+
"assignButtonText": {
|
|
676
|
+
"alias": "assignButtonText";
|
|
677
|
+
"required": true;
|
|
678
|
+
};
|
|
679
|
+
"back2OptionSelectionButtonText": {
|
|
680
|
+
"alias": "back2OptionSelectionButtonText";
|
|
681
|
+
"required": true;
|
|
682
|
+
};
|
|
683
|
+
"entity": {
|
|
684
|
+
"alias": "entity";
|
|
685
|
+
"required": true;
|
|
686
|
+
};
|
|
687
|
+
"text": {
|
|
688
|
+
"alias": "text";
|
|
689
|
+
"required": true;
|
|
690
|
+
};
|
|
691
|
+
"id": {
|
|
692
|
+
"alias": "id";
|
|
693
|
+
"required": true;
|
|
694
|
+
};
|
|
695
|
+
"back2OptionsSectionMode": {
|
|
696
|
+
"alias": "back2OptionsSectionMode";
|
|
697
|
+
"required": false;
|
|
698
|
+
};
|
|
699
|
+
}, {}, never, never, false, never>;
|
|
520
700
|
}
|
|
521
|
-
|
|
522
701
|
declare namespace Grammar {
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
702
|
+
enum PicturePosition {
|
|
703
|
+
Left = "left",
|
|
704
|
+
Right = "right"
|
|
705
|
+
}
|
|
706
|
+
type Media = {
|
|
707
|
+
url: string;
|
|
708
|
+
mimeType: string;
|
|
709
|
+
};
|
|
710
|
+
type Item = {
|
|
711
|
+
key: string;
|
|
712
|
+
color?: {
|
|
713
|
+
background?: string;
|
|
714
|
+
text?: string;
|
|
530
715
|
};
|
|
531
|
-
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
background?: string;
|
|
535
|
-
text?: string;
|
|
536
|
-
};
|
|
537
|
-
picture?: {
|
|
538
|
-
url: string;
|
|
539
|
-
position?: PicturePosition;
|
|
540
|
-
};
|
|
541
|
-
media?: Media;
|
|
542
|
-
innerHTML: string;
|
|
543
|
-
};
|
|
544
|
-
type Items = Item[];
|
|
545
|
-
type Content = {
|
|
546
|
-
lang: string;
|
|
547
|
-
input: Item[];
|
|
548
|
-
};
|
|
549
|
-
type Set = LearningEntityCommon & {
|
|
550
|
-
content: Content;
|
|
716
|
+
picture?: {
|
|
717
|
+
url: string;
|
|
718
|
+
position?: PicturePosition;
|
|
551
719
|
};
|
|
720
|
+
media?: Media;
|
|
721
|
+
innerHTML: string;
|
|
722
|
+
};
|
|
723
|
+
type Items = Item[];
|
|
724
|
+
type Content = {
|
|
725
|
+
lang: string;
|
|
726
|
+
input: Item[];
|
|
727
|
+
};
|
|
728
|
+
type Set = LearningEntityCommon & {
|
|
729
|
+
content: Content;
|
|
730
|
+
};
|
|
552
731
|
}
|
|
553
|
-
|
|
554
|
-
|
|
555
|
-
|
|
556
|
-
|
|
557
|
-
|
|
558
|
-
|
|
559
|
-
protected _init(entity: Grammar.Set): void;
|
|
732
|
+
export declare class GrammarLearningEntity extends LearningEntityBase {
|
|
733
|
+
private _grammars;
|
|
734
|
+
get icon(): string;
|
|
735
|
+
isCheckable(): boolean;
|
|
736
|
+
get content(): Grammar.Items;
|
|
737
|
+
protected _init(entity: Grammar.Set): void;
|
|
560
738
|
}
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
739
|
+
export declare class GrammarComponent extends CanvasComponent {
|
|
740
|
+
private _entity;
|
|
741
|
+
get entity(): GrammarLearningEntity;
|
|
742
|
+
set entity(entity: GrammarLearningEntity);
|
|
743
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<GrammarComponent, never>;
|
|
744
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<GrammarComponent, "edyta-grammar", never, {
|
|
745
|
+
"entity": {
|
|
746
|
+
"alias": "entity";
|
|
747
|
+
"required": true;
|
|
748
|
+
};
|
|
749
|
+
}, {}, never, never, false, never>;
|
|
568
750
|
}
|
|
569
|
-
|
|
570
751
|
declare namespace Vocabulary {
|
|
571
|
-
|
|
572
|
-
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
|
|
578
|
-
|
|
579
|
-
|
|
580
|
-
|
|
581
|
-
|
|
582
|
-
|
|
583
|
-
|
|
584
|
-
|
|
585
|
-
|
|
586
|
-
|
|
587
|
-
|
|
588
|
-
|
|
589
|
-
|
|
752
|
+
export enum FrontCardTitleVisibilityMode {
|
|
753
|
+
Visible = "visible",
|
|
754
|
+
Blurred = "blurred",
|
|
755
|
+
Invisible = "invisible"
|
|
756
|
+
}
|
|
757
|
+
type Meaning = {
|
|
758
|
+
lang: string;
|
|
759
|
+
text: string;
|
|
760
|
+
};
|
|
761
|
+
type Description = {
|
|
762
|
+
lang: string;
|
|
763
|
+
text: string;
|
|
764
|
+
};
|
|
765
|
+
export type Item = {
|
|
766
|
+
key: string;
|
|
767
|
+
meaning: Meaning[];
|
|
768
|
+
flip?: boolean;
|
|
769
|
+
description: Description[];
|
|
770
|
+
picture?: string;
|
|
771
|
+
};
|
|
772
|
+
export type Content = {
|
|
773
|
+
lang: string;
|
|
774
|
+
shuffle?: boolean;
|
|
775
|
+
shuffleButtonVisible?: boolean;
|
|
776
|
+
frontCardTitleVisibilityMode?: FrontCardTitleVisibilityMode;
|
|
777
|
+
input: Item[];
|
|
778
|
+
};
|
|
779
|
+
export type Set = LearningEntityCommon & {
|
|
780
|
+
content: Content;
|
|
781
|
+
};
|
|
782
|
+
export type TransformedItem = {
|
|
783
|
+
key: string;
|
|
784
|
+
meaning?: string;
|
|
785
|
+
flip?: boolean;
|
|
786
|
+
description?: string;
|
|
787
|
+
picture?: string;
|
|
788
|
+
};
|
|
789
|
+
export type TransformedItems = TransformedItem[];
|
|
790
|
+
export {};
|
|
791
|
+
}
|
|
792
|
+
export declare class VocabularyLearningEntity extends LearningEntityBase {
|
|
793
|
+
private _vocabularies;
|
|
794
|
+
private _shuffleActivated;
|
|
795
|
+
private _shuffleButtonEnabled;
|
|
796
|
+
private _frontCardTitleVisibilityMode;
|
|
797
|
+
get icon(): string;
|
|
798
|
+
isCheckable(): boolean;
|
|
799
|
+
get shuffleActivated(): boolean;
|
|
800
|
+
set shuffleActivated(activated: boolean);
|
|
801
|
+
get shuffleButtonEnabled(): boolean;
|
|
802
|
+
set shuffleButtonEnabled(enabled: boolean);
|
|
803
|
+
get frontCardTitleVisibilityMode(): Vocabulary.FrontCardTitleVisibilityMode;
|
|
804
|
+
set frontCardTitleVisibilityMode(mode: Vocabulary.FrontCardTitleVisibilityMode);
|
|
805
|
+
get content(): Vocabulary.TransformedItems;
|
|
806
|
+
onShuffle(): void;
|
|
807
|
+
protected _init(entity: Vocabulary.Set): void;
|
|
808
|
+
}
|
|
809
|
+
export declare class VocabularyComponent extends CanvasComponent implements AfterViewChecked, OnDestroy {
|
|
810
|
+
private _entity;
|
|
811
|
+
private _resizeEventListenerRegistered;
|
|
812
|
+
private _titleIsVisible;
|
|
813
|
+
visibilityButtonShowTitleText: string;
|
|
814
|
+
visibilityButtonHideTitleText: string;
|
|
815
|
+
shuffleButtonText: string;
|
|
816
|
+
get entity(): VocabularyLearningEntity;
|
|
817
|
+
set entity(entity: VocabularyLearningEntity);
|
|
818
|
+
get titleIsVisible(): boolean;
|
|
819
|
+
ngAfterViewChecked(): void;
|
|
820
|
+
ngOnDestroy(): void;
|
|
821
|
+
buttonPaneIsVisible(): boolean;
|
|
822
|
+
onToggleTitleVisibility(): void;
|
|
823
|
+
titleIsVisibleByDefault(): boolean;
|
|
824
|
+
getTitleVisibilityButtonText(): string;
|
|
825
|
+
private fitTextToCardTitle;
|
|
826
|
+
private fitTextToContainer;
|
|
827
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<VocabularyComponent, never>;
|
|
828
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<VocabularyComponent, "edyta-vocabulary", never, {
|
|
829
|
+
"visibilityButtonShowTitleText": {
|
|
830
|
+
"alias": "visibilityButtonShowTitleText";
|
|
831
|
+
"required": true;
|
|
590
832
|
};
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
shuffleButtonVisible?: boolean;
|
|
595
|
-
frontCardTitleVisibilityMode?: FrontCardTitleVisibilityMode;
|
|
596
|
-
input: Item[];
|
|
833
|
+
"visibilityButtonHideTitleText": {
|
|
834
|
+
"alias": "visibilityButtonHideTitleText";
|
|
835
|
+
"required": true;
|
|
597
836
|
};
|
|
598
|
-
|
|
599
|
-
|
|
837
|
+
"shuffleButtonText": {
|
|
838
|
+
"alias": "shuffleButtonText";
|
|
839
|
+
"required": true;
|
|
600
840
|
};
|
|
601
|
-
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
flip?: boolean;
|
|
605
|
-
description?: string;
|
|
606
|
-
picture?: string;
|
|
841
|
+
"entity": {
|
|
842
|
+
"alias": "entity";
|
|
843
|
+
"required": true;
|
|
607
844
|
};
|
|
608
|
-
|
|
609
|
-
export {};
|
|
610
|
-
}
|
|
611
|
-
|
|
612
|
-
declare class VocabularyLearningEntity extends LearningEntityBase {
|
|
613
|
-
private _vocabularies;
|
|
614
|
-
private _shuffleActivated;
|
|
615
|
-
private _shuffleButtonEnabled;
|
|
616
|
-
private _frontCardTitleVisibilityMode;
|
|
617
|
-
get icon(): string;
|
|
618
|
-
isCheckable(): boolean;
|
|
619
|
-
get shuffleActivated(): boolean;
|
|
620
|
-
set shuffleActivated(activated: boolean);
|
|
621
|
-
get shuffleButtonEnabled(): boolean;
|
|
622
|
-
set shuffleButtonEnabled(enabled: boolean);
|
|
623
|
-
get frontCardTitleVisibilityMode(): Vocabulary.FrontCardTitleVisibilityMode;
|
|
624
|
-
set frontCardTitleVisibilityMode(mode: Vocabulary.FrontCardTitleVisibilityMode);
|
|
625
|
-
get content(): Vocabulary.TransformedItems;
|
|
626
|
-
onShuffle(): void;
|
|
627
|
-
protected _init(entity: Vocabulary.Set): void;
|
|
628
|
-
}
|
|
629
|
-
|
|
630
|
-
declare class VocabularyComponent extends CanvasComponent implements AfterViewChecked, OnDestroy {
|
|
631
|
-
private _entity;
|
|
632
|
-
private _resizeEventListenerRegistered;
|
|
633
|
-
private _titleIsVisible;
|
|
634
|
-
visibilityButtonShowTitleText: string;
|
|
635
|
-
visibilityButtonHideTitleText: string;
|
|
636
|
-
shuffleButtonText: string;
|
|
637
|
-
get entity(): VocabularyLearningEntity;
|
|
638
|
-
set entity(entity: VocabularyLearningEntity);
|
|
639
|
-
get titleIsVisible(): boolean;
|
|
640
|
-
ngAfterViewChecked(): void;
|
|
641
|
-
ngOnDestroy(): void;
|
|
642
|
-
buttonPaneIsVisible(): boolean;
|
|
643
|
-
onToggleTitleVisibility(): void;
|
|
644
|
-
titleIsVisibleByDefault(): boolean;
|
|
645
|
-
getTitleVisibilityButtonText(): string;
|
|
646
|
-
private fitTextToCardTitle;
|
|
647
|
-
private fitTextToContainer;
|
|
648
|
-
static ɵfac: i0.ɵɵFactoryDeclaration<VocabularyComponent, never>;
|
|
649
|
-
static ɵcmp: i0.ɵɵComponentDeclaration<VocabularyComponent, "edyta-vocabulary", never, { "visibilityButtonShowTitleText": { "alias": "visibilityButtonShowTitleText"; "required": true; }; "visibilityButtonHideTitleText": { "alias": "visibilityButtonHideTitleText"; "required": true; }; "shuffleButtonText": { "alias": "shuffleButtonText"; "required": true; }; "entity": { "alias": "entity"; "required": true; }; }, {}, never, never, false, never>;
|
|
845
|
+
}, {}, never, never, false, never>;
|
|
650
846
|
}
|
|
651
|
-
|
|
652
847
|
declare namespace Form {
|
|
653
|
-
|
|
654
|
-
|
|
655
|
-
|
|
656
|
-
|
|
657
|
-
|
|
658
|
-
|
|
659
|
-
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
};
|
|
677
|
-
options?: Option[];
|
|
678
|
-
mandatory?: boolean;
|
|
679
|
-
};
|
|
680
|
-
type Text = GenericInput;
|
|
681
|
-
type Input = Text & {
|
|
682
|
-
state: string;
|
|
683
|
-
};
|
|
684
|
-
type Date = Input;
|
|
685
|
-
type Select = Input & {
|
|
686
|
-
options: Option[];
|
|
687
|
-
};
|
|
688
|
-
type Radio = Select;
|
|
689
|
-
type CheckboxOption = Option & {
|
|
690
|
-
checked: boolean;
|
|
691
|
-
};
|
|
692
|
-
type Checkbox = GenericInput & {
|
|
693
|
-
options: CheckboxOption[];
|
|
694
|
-
};
|
|
695
|
-
type UkuleleChord = Text & {
|
|
696
|
-
ukuleleChords: ChordKey[];
|
|
697
|
-
};
|
|
698
|
-
type CheckboxProgressStateItem = {
|
|
699
|
-
id: string;
|
|
700
|
-
checked: boolean;
|
|
701
|
-
};
|
|
702
|
-
type CheckboxProgressStateItems = CheckboxProgressStateItem[];
|
|
703
|
-
type ProgressItem = {
|
|
704
|
-
key: string;
|
|
705
|
-
state: string | CheckboxProgressStateItems;
|
|
706
|
-
};
|
|
707
|
-
type Progress = ProgressItem[] | null | undefined;
|
|
708
|
-
type Item = (Text | Date | Checkbox | Radio | Select | Input);
|
|
709
|
-
type Items = Item[];
|
|
710
|
-
type Content = {
|
|
711
|
-
type: string;
|
|
712
|
-
title: string;
|
|
713
|
-
lang: string;
|
|
714
|
-
input: Items;
|
|
715
|
-
};
|
|
716
|
-
type Set = LearningEntityCommon & {
|
|
717
|
-
content: Content;
|
|
718
|
-
progress: Progress;
|
|
848
|
+
type Option = {
|
|
849
|
+
id: string;
|
|
850
|
+
text: string;
|
|
851
|
+
};
|
|
852
|
+
type Media = {
|
|
853
|
+
url: string;
|
|
854
|
+
mimeType: string;
|
|
855
|
+
};
|
|
856
|
+
type Picture = {
|
|
857
|
+
url: string;
|
|
858
|
+
alwaysVisible?: boolean;
|
|
859
|
+
};
|
|
860
|
+
type GenericInput = {
|
|
861
|
+
key: string;
|
|
862
|
+
type: string;
|
|
863
|
+
text: string;
|
|
864
|
+
description?: string;
|
|
865
|
+
divider?: boolean;
|
|
866
|
+
media?: Media;
|
|
867
|
+
picture?: Picture | string;
|
|
868
|
+
color?: {
|
|
869
|
+
background?: string;
|
|
870
|
+
text?: string;
|
|
719
871
|
};
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
872
|
+
options?: Option[];
|
|
873
|
+
mandatory?: boolean;
|
|
874
|
+
};
|
|
875
|
+
type Text = GenericInput;
|
|
876
|
+
type Input = Text & {
|
|
877
|
+
state: string;
|
|
878
|
+
};
|
|
879
|
+
type Date = Input;
|
|
880
|
+
type Select = Input & {
|
|
881
|
+
options: Option[];
|
|
882
|
+
};
|
|
883
|
+
type Radio = Select;
|
|
884
|
+
type CheckboxOption = Option & {
|
|
885
|
+
checked: boolean;
|
|
886
|
+
};
|
|
887
|
+
type Checkbox = GenericInput & {
|
|
888
|
+
options: CheckboxOption[];
|
|
889
|
+
};
|
|
890
|
+
type UkuleleChord = Text & {
|
|
891
|
+
ukuleleChords: ChordKey[];
|
|
892
|
+
};
|
|
893
|
+
type CheckboxProgressStateItem = {
|
|
894
|
+
id: string;
|
|
895
|
+
checked: boolean;
|
|
896
|
+
};
|
|
897
|
+
type CheckboxProgressStateItems = CheckboxProgressStateItem[];
|
|
898
|
+
type ProgressItem = {
|
|
899
|
+
key: string;
|
|
900
|
+
state: string | CheckboxProgressStateItems;
|
|
901
|
+
};
|
|
902
|
+
type Progress = ProgressItem[] | null | undefined;
|
|
903
|
+
type Item = (Text | Date | Checkbox | Radio | Select | Input);
|
|
904
|
+
type Items = Item[];
|
|
905
|
+
type Content = {
|
|
906
|
+
type: string;
|
|
907
|
+
title: string;
|
|
908
|
+
lang: string;
|
|
909
|
+
input: Items;
|
|
910
|
+
};
|
|
911
|
+
type Set = LearningEntityCommon & {
|
|
912
|
+
content: Content;
|
|
913
|
+
progress: Progress;
|
|
914
|
+
};
|
|
915
|
+
type ResultItem = {
|
|
916
|
+
key: string;
|
|
917
|
+
correct: string[] | string;
|
|
918
|
+
optional?: string[] | string;
|
|
919
|
+
};
|
|
920
|
+
type Result = ResultItem[];
|
|
726
921
|
}
|
|
727
|
-
|
|
728
|
-
|
|
729
|
-
|
|
730
|
-
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
|
|
734
|
-
|
|
735
|
-
|
|
736
|
-
protected _init(entity: Form.Set): void;
|
|
922
|
+
export declare class FormLearningEntity extends InteractiveLearningEntityBase {
|
|
923
|
+
private _content;
|
|
924
|
+
private _progress;
|
|
925
|
+
get icon(): string;
|
|
926
|
+
isCheckable(): boolean;
|
|
927
|
+
get progress(): Form.Progress;
|
|
928
|
+
set progress(progress: Form.Progress);
|
|
929
|
+
get content(): Form.Items;
|
|
930
|
+
protected _init(entity: Form.Set): void;
|
|
737
931
|
}
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
744
|
-
|
|
745
|
-
|
|
746
|
-
|
|
747
|
-
|
|
748
|
-
|
|
749
|
-
|
|
750
|
-
|
|
751
|
-
|
|
752
|
-
|
|
753
|
-
|
|
932
|
+
export declare class FormComponent extends CanvasComponent {
|
|
933
|
+
private _entity;
|
|
934
|
+
private _formItems;
|
|
935
|
+
constructor();
|
|
936
|
+
get entity(): FormLearningEntity;
|
|
937
|
+
set entity(entity: FormLearningEntity);
|
|
938
|
+
get formItems(): Form.Items;
|
|
939
|
+
set formItems(form: Form.Items);
|
|
940
|
+
onChange(): void;
|
|
941
|
+
private _process;
|
|
942
|
+
private _prepareState;
|
|
943
|
+
private _buildProgressSnapshot;
|
|
944
|
+
private _applyProgress2State;
|
|
945
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<FormComponent, never>;
|
|
946
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<FormComponent, "edyta-form", never, {
|
|
947
|
+
"entity": {
|
|
948
|
+
"alias": "entity";
|
|
949
|
+
"required": true;
|
|
950
|
+
};
|
|
951
|
+
}, {}, never, never, false, never>;
|
|
754
952
|
}
|
|
755
|
-
|
|
756
953
|
declare class FormTypeTextComponent {
|
|
757
|
-
|
|
758
|
-
|
|
954
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeTextComponent, never>;
|
|
955
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeTextComponent, "edyta-form-type-text", never, {}, {}, never, never, false, never>;
|
|
759
956
|
}
|
|
760
|
-
|
|
761
957
|
declare class FormTypeInputComponent extends CanvasComponent {
|
|
762
|
-
|
|
763
|
-
|
|
764
|
-
|
|
765
|
-
|
|
766
|
-
|
|
767
|
-
|
|
958
|
+
private _content;
|
|
959
|
+
get content(): Form.Input;
|
|
960
|
+
set content(value: Form.Input);
|
|
961
|
+
onChange(): void;
|
|
962
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeInputComponent, never>;
|
|
963
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeInputComponent, "edyta-form-type-input", never, {
|
|
964
|
+
"content": {
|
|
965
|
+
"alias": "content";
|
|
966
|
+
"required": false;
|
|
967
|
+
};
|
|
968
|
+
}, {}, never, never, false, never>;
|
|
768
969
|
}
|
|
769
|
-
|
|
770
970
|
declare class FormTypeSelectComponent extends CanvasComponent {
|
|
771
|
-
|
|
772
|
-
|
|
773
|
-
|
|
774
|
-
|
|
775
|
-
|
|
776
|
-
|
|
971
|
+
private _content;
|
|
972
|
+
get content(): Form.Select;
|
|
973
|
+
set content(value: Form.Select);
|
|
974
|
+
onChange(): void;
|
|
975
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeSelectComponent, never>;
|
|
976
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeSelectComponent, "edyta-form-type-select", never, {
|
|
977
|
+
"content": {
|
|
978
|
+
"alias": "content";
|
|
979
|
+
"required": false;
|
|
980
|
+
};
|
|
981
|
+
}, {}, never, never, false, never>;
|
|
777
982
|
}
|
|
778
|
-
|
|
779
983
|
declare class FormTypeRadioComponent extends CanvasComponent {
|
|
780
|
-
|
|
781
|
-
|
|
782
|
-
|
|
783
|
-
|
|
784
|
-
|
|
785
|
-
|
|
984
|
+
private _content;
|
|
985
|
+
get content(): Form.Radio;
|
|
986
|
+
set content(value: Form.Radio);
|
|
987
|
+
onChange(): void;
|
|
988
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeRadioComponent, never>;
|
|
989
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeRadioComponent, "edyta-form-type-radio", never, {
|
|
990
|
+
"content": {
|
|
991
|
+
"alias": "content";
|
|
992
|
+
"required": false;
|
|
993
|
+
};
|
|
994
|
+
}, {}, never, never, false, never>;
|
|
786
995
|
}
|
|
787
|
-
|
|
788
996
|
declare class FormTypeCheckboxComponent extends CanvasComponent {
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
|
|
997
|
+
private _content;
|
|
998
|
+
get content(): Form.Checkbox;
|
|
999
|
+
set content(value: Form.Checkbox);
|
|
1000
|
+
onChange(): void;
|
|
1001
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeCheckboxComponent, never>;
|
|
1002
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeCheckboxComponent, "edyta-form-type-checkbox", never, {
|
|
1003
|
+
"content": {
|
|
1004
|
+
"alias": "content";
|
|
1005
|
+
"required": false;
|
|
1006
|
+
};
|
|
1007
|
+
}, {}, never, never, false, never>;
|
|
795
1008
|
}
|
|
796
|
-
|
|
797
1009
|
declare class FormTypeDateComponent extends CanvasComponent {
|
|
798
|
-
|
|
799
|
-
|
|
800
|
-
|
|
801
|
-
|
|
802
|
-
|
|
803
|
-
|
|
1010
|
+
private _content;
|
|
1011
|
+
get content(): Form.Date;
|
|
1012
|
+
set content(value: Form.Date);
|
|
1013
|
+
onChange(): void;
|
|
1014
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeDateComponent, never>;
|
|
1015
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeDateComponent, "edyta-form-type-date", never, {
|
|
1016
|
+
"content": {
|
|
1017
|
+
"alias": "content";
|
|
1018
|
+
"required": false;
|
|
1019
|
+
};
|
|
1020
|
+
}, {}, never, never, false, never>;
|
|
804
1021
|
}
|
|
805
|
-
|
|
806
1022
|
declare class FormTypeUkuleleChordsComponent extends CanvasComponent {
|
|
807
|
-
|
|
808
|
-
|
|
809
|
-
|
|
1023
|
+
content: Form.UkuleleChord;
|
|
1024
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeUkuleleChordsComponent, never>;
|
|
1025
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeUkuleleChordsComponent, "edyta-form-type-ukulele-chords", never, {
|
|
1026
|
+
"content": {
|
|
1027
|
+
"alias": "content";
|
|
1028
|
+
"required": true;
|
|
1029
|
+
};
|
|
1030
|
+
}, {}, never, never, false, never>;
|
|
810
1031
|
}
|
|
811
|
-
|
|
812
1032
|
declare class FormTypeItemComponent extends CanvasComponent {
|
|
813
|
-
|
|
814
|
-
|
|
815
|
-
|
|
816
|
-
|
|
817
|
-
|
|
818
|
-
|
|
819
|
-
|
|
820
|
-
|
|
821
|
-
|
|
822
|
-
|
|
1033
|
+
private _content;
|
|
1034
|
+
get content(): Form.Input | Form.Text | Form.Checkbox | Form.Date | Form.Radio | Form.Select;
|
|
1035
|
+
set content(value: Form.Input | Form.Text | Form.Checkbox | Form.Date | Form.Radio | Form.Select);
|
|
1036
|
+
showDecriptionSection(): boolean;
|
|
1037
|
+
showMedia(): boolean;
|
|
1038
|
+
showPicture(): boolean;
|
|
1039
|
+
isPictureAlwaysVisible(): boolean;
|
|
1040
|
+
onChange(): void;
|
|
1041
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeItemComponent, never>;
|
|
1042
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeItemComponent, "edyta-form-type-item", never, {
|
|
1043
|
+
"content": {
|
|
1044
|
+
"alias": "content";
|
|
1045
|
+
"required": false;
|
|
1046
|
+
};
|
|
1047
|
+
}, {}, never, never, false, never>;
|
|
823
1048
|
}
|
|
824
|
-
|
|
825
1049
|
declare abstract class VocabularyCardBaseComponent {
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
830
|
-
|
|
831
|
-
|
|
832
|
-
|
|
833
|
-
|
|
834
|
-
|
|
835
|
-
|
|
836
|
-
|
|
837
|
-
|
|
838
|
-
|
|
839
|
-
|
|
840
|
-
|
|
841
|
-
|
|
842
|
-
|
|
843
|
-
|
|
1050
|
+
private _vocabulary;
|
|
1051
|
+
private _frontCardTitleVisibilityMode;
|
|
1052
|
+
private _titleIsVisible;
|
|
1053
|
+
get vocabulary(): Vocabulary.TransformedItem;
|
|
1054
|
+
set vocabulary(value: Vocabulary.TransformedItem);
|
|
1055
|
+
get frontCardTitleVisibilityMode(): Vocabulary.FrontCardTitleVisibilityMode;
|
|
1056
|
+
set frontCardTitleVisibilityMode(mode: Vocabulary.FrontCardTitleVisibilityMode);
|
|
1057
|
+
get titleIsVisible(): boolean;
|
|
1058
|
+
set titleIsVisible(visible: boolean);
|
|
1059
|
+
calculateHtmlClasses4Title(): {
|
|
1060
|
+
'card__face-front-blur'?: undefined;
|
|
1061
|
+
'card__face-front-invisible'?: undefined;
|
|
1062
|
+
} | {
|
|
1063
|
+
'card__face-front-blur': boolean;
|
|
1064
|
+
'card__face-front-invisible': boolean;
|
|
1065
|
+
};
|
|
1066
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<VocabularyCardBaseComponent, never>;
|
|
1067
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<VocabularyCardBaseComponent, "ng-component", never, {
|
|
1068
|
+
"vocabulary": {
|
|
1069
|
+
"alias": "vocabulary";
|
|
1070
|
+
"required": true;
|
|
1071
|
+
};
|
|
1072
|
+
"frontCardTitleVisibilityMode": {
|
|
1073
|
+
"alias": "frontCardTitleVisibilityMode";
|
|
1074
|
+
"required": true;
|
|
1075
|
+
};
|
|
1076
|
+
"titleIsVisible": {
|
|
1077
|
+
"alias": "titleIsVisible";
|
|
1078
|
+
"required": false;
|
|
1079
|
+
};
|
|
1080
|
+
}, {}, never, never, false, never>;
|
|
844
1081
|
}
|
|
845
|
-
|
|
846
1082
|
declare class VocabularyCardFlipComponent extends VocabularyCardBaseComponent {
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
850
|
-
|
|
851
|
-
|
|
852
|
-
|
|
853
|
-
|
|
1083
|
+
private _flipped;
|
|
1084
|
+
get flipped(): boolean;
|
|
1085
|
+
set flipped(value: boolean);
|
|
1086
|
+
onToggleFlip(): void;
|
|
1087
|
+
get descriptionImageUrl(): string | null;
|
|
1088
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<VocabularyCardFlipComponent, never>;
|
|
1089
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<VocabularyCardFlipComponent, "edyta-vocabulary-card-flip", never, {}, {}, never, never, false, never>;
|
|
854
1090
|
}
|
|
855
|
-
|
|
856
1091
|
declare class VocabularyCardStandardComponent extends VocabularyCardBaseComponent {
|
|
857
|
-
|
|
858
|
-
|
|
1092
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<VocabularyCardStandardComponent, never>;
|
|
1093
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<VocabularyCardStandardComponent, "edyta-vocabulary-card-standard", never, {}, {}, never, never, false, never>;
|
|
859
1094
|
}
|
|
860
|
-
|
|
861
1095
|
declare class GrammarItemComponent {
|
|
862
|
-
|
|
863
|
-
|
|
864
|
-
|
|
865
|
-
|
|
866
|
-
|
|
867
|
-
|
|
1096
|
+
content: Grammar.Item;
|
|
1097
|
+
showMedia(): boolean;
|
|
1098
|
+
showPictureOnLeft(): boolean;
|
|
1099
|
+
showPictureOnRight(): boolean;
|
|
1100
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<GrammarItemComponent, never>;
|
|
1101
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<GrammarItemComponent, "edyta-grammar-item", never, {
|
|
1102
|
+
"content": {
|
|
1103
|
+
"alias": "content";
|
|
1104
|
+
"required": false;
|
|
1105
|
+
};
|
|
1106
|
+
}, {}, never, never, false, never>;
|
|
868
1107
|
}
|
|
869
|
-
|
|
870
1108
|
declare namespace Riddle {
|
|
871
|
-
|
|
872
|
-
|
|
873
|
-
|
|
874
|
-
|
|
875
|
-
|
|
876
|
-
|
|
877
|
-
|
|
878
|
-
|
|
879
|
-
|
|
880
|
-
|
|
881
|
-
|
|
882
|
-
|
|
883
|
-
|
|
884
|
-
|
|
885
|
-
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
|
|
891
|
-
|
|
892
|
-
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
-
|
|
897
|
-
|
|
898
|
-
|
|
899
|
-
|
|
900
|
-
|
|
901
|
-
|
|
902
|
-
|
|
903
|
-
|
|
904
|
-
|
|
905
|
-
|
|
906
|
-
|
|
907
|
-
|
|
908
|
-
|
|
909
|
-
|
|
910
|
-
|
|
911
|
-
|
|
912
|
-
|
|
1109
|
+
type Media = {
|
|
1110
|
+
url: string;
|
|
1111
|
+
mimeType: string;
|
|
1112
|
+
};
|
|
1113
|
+
type Option = {
|
|
1114
|
+
id: string;
|
|
1115
|
+
text: string;
|
|
1116
|
+
};
|
|
1117
|
+
type GenericInput = {
|
|
1118
|
+
key: string;
|
|
1119
|
+
type: string;
|
|
1120
|
+
options?: Option[];
|
|
1121
|
+
};
|
|
1122
|
+
type Input = GenericInput & {
|
|
1123
|
+
state: string;
|
|
1124
|
+
};
|
|
1125
|
+
type Select = Input & {
|
|
1126
|
+
options: Option[];
|
|
1127
|
+
};
|
|
1128
|
+
type ResultItem = {
|
|
1129
|
+
key: string;
|
|
1130
|
+
correct: string[] | string;
|
|
1131
|
+
};
|
|
1132
|
+
type Result = ResultItem[];
|
|
1133
|
+
type ProgressItem = {
|
|
1134
|
+
key: string;
|
|
1135
|
+
state: string;
|
|
1136
|
+
};
|
|
1137
|
+
type Progress = ProgressItem[] | null | undefined;
|
|
1138
|
+
type Items = (Input | Select)[];
|
|
1139
|
+
type Content = {
|
|
1140
|
+
type: string;
|
|
1141
|
+
title: string;
|
|
1142
|
+
innerHTML: string;
|
|
1143
|
+
media: Media;
|
|
1144
|
+
lang: string;
|
|
1145
|
+
input: Items;
|
|
1146
|
+
};
|
|
1147
|
+
type Set = LearningEntityCommon & {
|
|
1148
|
+
content: Content;
|
|
1149
|
+
progress: Progress;
|
|
1150
|
+
};
|
|
913
1151
|
}
|
|
914
|
-
|
|
915
|
-
|
|
916
|
-
|
|
917
|
-
|
|
918
|
-
|
|
919
|
-
|
|
920
|
-
|
|
921
|
-
|
|
922
|
-
|
|
923
|
-
protected _init(entity: Riddle.Set): void;
|
|
1152
|
+
export declare class RiddleLearningEntity extends InteractiveLearningEntityBase {
|
|
1153
|
+
private _content;
|
|
1154
|
+
private _progress;
|
|
1155
|
+
get icon(): string;
|
|
1156
|
+
isCheckable(): boolean;
|
|
1157
|
+
get progress(): Riddle.Progress;
|
|
1158
|
+
set progress(progress: Riddle.Progress);
|
|
1159
|
+
get content(): Riddle.Content;
|
|
1160
|
+
protected _init(entity: Riddle.Set): void;
|
|
924
1161
|
}
|
|
925
|
-
|
|
926
|
-
|
|
927
|
-
|
|
928
|
-
|
|
929
|
-
|
|
930
|
-
|
|
931
|
-
|
|
932
|
-
|
|
933
|
-
|
|
934
|
-
|
|
935
|
-
|
|
936
|
-
|
|
937
|
-
|
|
938
|
-
|
|
939
|
-
|
|
940
|
-
|
|
941
|
-
|
|
942
|
-
|
|
943
|
-
|
|
944
|
-
|
|
945
|
-
|
|
946
|
-
|
|
947
|
-
|
|
1162
|
+
export declare class RiddleComponent extends CanvasComponent implements AfterViewChecked {
|
|
1163
|
+
private _sanitizer;
|
|
1164
|
+
private _router;
|
|
1165
|
+
private _html;
|
|
1166
|
+
private _entity;
|
|
1167
|
+
private _eventListenerAdded;
|
|
1168
|
+
errorReceived: EventEmitter<Error>;
|
|
1169
|
+
constructor(_sanitizer: DomSanitizer, _router: Router);
|
|
1170
|
+
ngAfterViewChecked(): void;
|
|
1171
|
+
get entity(): RiddleLearningEntity;
|
|
1172
|
+
set entity(entity: RiddleLearningEntity);
|
|
1173
|
+
get html(): SafeHtml;
|
|
1174
|
+
set html(value: SafeHtml);
|
|
1175
|
+
private _process;
|
|
1176
|
+
private _prepareState;
|
|
1177
|
+
private _applyProgress2State;
|
|
1178
|
+
private _deriveRiddleItemByElement;
|
|
1179
|
+
private _determineHTMLEvent;
|
|
1180
|
+
private _isEventListenerAdded;
|
|
1181
|
+
private _buildProgressSnapshot;
|
|
1182
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<RiddleComponent, never>;
|
|
1183
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<RiddleComponent, "edyta-riddle", never, {
|
|
1184
|
+
"entity": {
|
|
1185
|
+
"alias": "entity";
|
|
1186
|
+
"required": true;
|
|
1187
|
+
};
|
|
1188
|
+
}, {
|
|
1189
|
+
"errorReceived": "errorReceived";
|
|
1190
|
+
}, never, never, false, never>;
|
|
948
1191
|
}
|
|
949
|
-
|
|
950
1192
|
declare namespace YesNo {
|
|
951
|
-
|
|
952
|
-
|
|
953
|
-
|
|
954
|
-
|
|
955
|
-
|
|
956
|
-
|
|
957
|
-
|
|
958
|
-
|
|
959
|
-
|
|
960
|
-
|
|
961
|
-
|
|
962
|
-
|
|
963
|
-
|
|
964
|
-
|
|
965
|
-
|
|
966
|
-
|
|
967
|
-
|
|
968
|
-
|
|
969
|
-
|
|
970
|
-
|
|
971
|
-
|
|
972
|
-
|
|
973
|
-
|
|
974
|
-
|
|
975
|
-
|
|
976
|
-
|
|
977
|
-
|
|
1193
|
+
type Media = {
|
|
1194
|
+
url: string;
|
|
1195
|
+
mimeType: string;
|
|
1196
|
+
};
|
|
1197
|
+
type ResultItem = {
|
|
1198
|
+
key: string;
|
|
1199
|
+
question: string;
|
|
1200
|
+
answer: string;
|
|
1201
|
+
};
|
|
1202
|
+
type ProgressItem = {
|
|
1203
|
+
key: string;
|
|
1204
|
+
answer: boolean | undefined;
|
|
1205
|
+
};
|
|
1206
|
+
type Progress = ProgressItem[] | null | undefined;
|
|
1207
|
+
type ResultItems = ResultItem[];
|
|
1208
|
+
type Content = {
|
|
1209
|
+
type: string;
|
|
1210
|
+
title: string;
|
|
1211
|
+
innerHTML: string;
|
|
1212
|
+
media?: Media;
|
|
1213
|
+
lang: string;
|
|
1214
|
+
input: ResultItems;
|
|
1215
|
+
};
|
|
1216
|
+
type Set = LearningEntityCommon & {
|
|
1217
|
+
content: Content;
|
|
1218
|
+
progress: Progress;
|
|
1219
|
+
};
|
|
978
1220
|
}
|
|
979
|
-
|
|
980
|
-
|
|
981
|
-
|
|
982
|
-
|
|
983
|
-
|
|
984
|
-
|
|
985
|
-
|
|
986
|
-
|
|
987
|
-
|
|
988
|
-
protected _init(entity: YesNo.Set): void;
|
|
1221
|
+
export declare class YesNoLearningEntity extends InteractiveLearningEntityBase {
|
|
1222
|
+
private _content;
|
|
1223
|
+
private _progress;
|
|
1224
|
+
get icon(): string;
|
|
1225
|
+
isCheckable(): boolean;
|
|
1226
|
+
get progress(): YesNo.Progress;
|
|
1227
|
+
set progress(progress: YesNo.Progress);
|
|
1228
|
+
get content(): YesNo.Content;
|
|
1229
|
+
protected _init(entity: YesNo.Set): void;
|
|
989
1230
|
}
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
|
|
995
|
-
|
|
996
|
-
|
|
997
|
-
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
|
|
1003
|
-
|
|
1231
|
+
export declare class YesnoComponent extends CanvasComponent {
|
|
1232
|
+
private _entity;
|
|
1233
|
+
get entity(): YesNoLearningEntity;
|
|
1234
|
+
set entity(entity: YesNoLearningEntity);
|
|
1235
|
+
onChange(): void;
|
|
1236
|
+
showMedia(): boolean;
|
|
1237
|
+
private _process;
|
|
1238
|
+
private _prepareState;
|
|
1239
|
+
private _applyProgress2State;
|
|
1240
|
+
private buildProgressSnapshot;
|
|
1241
|
+
private calculateAnswer;
|
|
1242
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<YesnoComponent, never>;
|
|
1243
|
+
static ɵcmp: i0.ɵɵComponentDeclaration<YesnoComponent, "edyta-yes-no", never, {
|
|
1244
|
+
"entity": {
|
|
1245
|
+
"alias": "entity";
|
|
1246
|
+
"required": true;
|
|
1247
|
+
};
|
|
1248
|
+
}, {}, never, never, false, never>;
|
|
1004
1249
|
}
|
|
1005
|
-
|
|
1006
1250
|
declare class AlignedHtmlDirective {
|
|
1007
|
-
|
|
1008
|
-
|
|
1009
|
-
|
|
1010
|
-
|
|
1011
|
-
|
|
1251
|
+
private readonly document;
|
|
1252
|
+
html: string;
|
|
1253
|
+
set edytaAlignedHtml(value: string | null | undefined);
|
|
1254
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<AlignedHtmlDirective, never>;
|
|
1255
|
+
static ɵdir: i0.ɵɵDirectiveDeclaration<AlignedHtmlDirective, "[edytaAlignedHtml]", never, {
|
|
1256
|
+
"edytaAlignedHtml": {
|
|
1257
|
+
"alias": "edytaAlignedHtml";
|
|
1258
|
+
"required": false;
|
|
1259
|
+
};
|
|
1260
|
+
}, {}, never, never, true, never>;
|
|
1012
1261
|
}
|
|
1013
|
-
|
|
1014
|
-
|
|
1015
|
-
|
|
1016
|
-
|
|
1017
|
-
static ɵinj: i0.ɵɵInjectorDeclaration<CanvasModule>;
|
|
1262
|
+
export declare class CanvasModule {
|
|
1263
|
+
static ɵfac: i0.ɵɵFactoryDeclaration<CanvasModule, never>;
|
|
1264
|
+
static ɵmod: i0.ɵɵNgModuleDeclaration<CanvasModule, [typeof CanvasComponent, typeof EntityBottomPaneComponent, typeof PuzzleComponent, typeof PuzzleTargetComponent, typeof PuzzleOptionComponent, typeof PuzzleOptionDialogComponent, typeof PuzzleFactComponent, typeof GrammarComponent, typeof VocabularyComponent, typeof FormComponent, typeof FormTypeTextComponent, typeof FormTypeInputComponent, typeof FormTypeSelectComponent, typeof FormTypeRadioComponent, typeof FormTypeCheckboxComponent, typeof FormTypeDateComponent, typeof FormTypeUkuleleChordsComponent, typeof FormTypeItemComponent, typeof VocabularyCardFlipComponent, typeof VocabularyCardStandardComponent, typeof GrammarItemComponent, typeof RiddleComponent, typeof YesnoComponent], [typeof i24.CommonModule, typeof i25.RouterModule, typeof i26.FormsModule, typeof i27.ElementModule, typeof i28.ChordModule, typeof AlignedHtmlDirective], [typeof CanvasComponent, typeof EntityBottomPaneComponent, typeof PuzzleComponent, typeof GrammarComponent, typeof VocabularyComponent, typeof FormComponent, typeof RiddleComponent, typeof YesnoComponent]>;
|
|
1265
|
+
static ɵinj: i0.ɵɵInjectorDeclaration<CanvasModule>;
|
|
1018
1266
|
}
|
|
1019
|
-
|
|
1020
|
-
|
|
1021
|
-
static create(entity: LearningEntityCommon, centralService: CentralService, learningEntityService: LearningEntityService): PuzzleLearningEntity | GrammarLearningEntity | VocabularyLearningEntity | FormLearningEntity | RiddleLearningEntity | YesNoLearningEntity;
|
|
1267
|
+
export declare class LearningEntityFactory {
|
|
1268
|
+
static create(entity: LearningEntityCommon, centralService: CentralService, learningEntityService: LearningEntityService): PuzzleLearningEntity | GrammarLearningEntity | VocabularyLearningEntity | FormLearningEntity | RiddleLearningEntity | YesNoLearningEntity;
|
|
1022
1269
|
}
|
|
1023
|
-
|
|
1024
|
-
export { CanvasComponent, CanvasModule, EntityAccess, EntityBottomPaneComponent, FormComponent, FormLearningEntity, GrammarComponent, GrammarLearningEntity, InteractiveLearningEntityBase, LearningEntityBase, LearningEntityFactory, PuzzleComponent, PuzzleLearningEntity, RiddleComponent, RiddleLearningEntity, VocabularyComponent, VocabularyLearningEntity, YesNoLearningEntity, YesnoComponent };
|
|
1025
|
-
export type { Entity, Evaluation, InteractiveLearningEntity, LearningEntity, LearningEntityAssignment, LearningEntityCommon, LearningEntityDescription, LearningEntityService, NextPreviousResult };
|
|
1270
|
+
export {};
|