ngx-edyta-entity 0.2.18 → 0.2.22

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.
@@ -1,1025 +1,1270 @@
1
- import * as i0 from '@angular/core';
2
- import { EventEmitter, AfterViewChecked, 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
-
14
- declare class CanvasComponent {
15
- static _dependencies: {
16
- EventEmitter: {
17
- new (isAsync?: boolean): EventEmitter<any>;
18
- new <T>(isAsync?: boolean): EventEmitter<T>;
19
- readonly prototype: EventEmitter<any>;
20
- };
21
- };
22
- private _title;
23
- private _picture;
24
- private _contentChange;
25
- private _evaluate;
26
- checkButtonText: string;
27
- previousButtonText: string;
28
- nextButtonText: string;
29
- showBottomPane: boolean;
30
- constructor();
31
- get contentChange(): EventEmitter<unknown>;
32
- set contentChange(value: EventEmitter<unknown>);
33
- get evaluate(): EventEmitter<void>;
34
- set evaluate(value: EventEmitter<void>);
35
- get title(): string;
36
- set title(value: string);
37
- get picture(): string | null;
38
- set picture(value: string | null);
39
- onEvaluate(): void;
40
- static ɵfac: i0.ɵɵFactoryDeclaration<CanvasComponent, never>;
41
- static ɵcmp: i0.ɵɵComponentDeclaration<CanvasComponent, "edyta-canvas", never, { "checkButtonText": { "alias": "checkButtonText"; "required": true; }; "previousButtonText": { "alias": "previousButtonText"; "required": true; }; "nextButtonText": { "alias": "nextButtonText"; "required": true; }; "showBottomPane": { "alias": "showBottomPane"; "required": false; }; "title": { "alias": "title"; "required": false; }; "picture": { "alias": "picture"; "required": false; }; }, { "contentChange": "contentChange"; "evaluate": "evaluate"; }, never, ["[breadcrumb]", "[control-panel]", "*"], false, never>;
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
- getDefault(): string;
46
- get(): string;
47
- set(language: string): void;
48
- remove(): void;
49
- supportedLanguages(): string[];
71
+ getDefault(): string;
72
+ get(): string;
73
+ set(language: string): void;
74
+ remove(): void;
75
+ supportedLanguages(): string[];
50
76
  }
51
77
  interface NotificationService {
52
- info(message: string): void;
53
- success(message: string): void;
54
- warning(message: string): void;
55
- error(message: string): void;
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
- getLanguageService(): LanguageService;
59
- getNotificationService(): NotificationService;
60
- getTranslateService(): TranslateService;
84
+ getLanguageService(): LanguageService;
85
+ getNotificationService(): NotificationService;
86
+ getTranslateService(): TranslateService;
61
87
  }
62
-
63
- interface InteractiveLearningEntity extends LearningEntity {
64
- get progress(): unknown;
65
- set progress(progress: unknown);
66
- updateProgress(): Observable<unknown>;
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
- abstract get progress(): unknown;
71
- abstract set progress(progress: unknown);
72
- updateProgress(): Observable<unknown>;
73
- deleteProgress(): Observable<void>;
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
- update(entity: InteractiveLearningEntity): Observable<unknown>;
78
- delete(entity: InteractiveLearningEntity): Observable<void>;
101
+ update(entity: InteractiveLearningEntity): Observable<unknown>;
102
+ delete(entity: InteractiveLearningEntity): Observable<void>;
79
103
  }
80
-
81
- type Entity = {
104
+ export type Entity = {
105
+ id: number;
106
+ title: string;
107
+ type: {
82
108
  id: number;
109
+ key: string;
83
110
  title: string;
84
- type: {
85
- id: number;
86
- key: string;
87
- title: string;
88
- description?: string | null;
89
- };
90
- version?: {
91
- id: number;
92
- isActive: boolean;
93
- };
94
- organization?: {
95
- id: number;
96
- key: string;
97
- };
98
- level: {
99
- id: number;
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
- correct: boolean;
129
+ export type Evaluation = {
130
+ correct: boolean;
108
131
  };
109
- interface LearningEntityService {
110
- get(organizationKey: string, levelId: number, id: number): Observable<LearningEntity>;
111
- getAll(organizationKey: string, levelId: number): Observable<LearningEntity[]>;
112
- evaluate(entity: InteractiveLearningEntity): Observable<Evaluation>;
113
- getProgressService(): LearningEntityProgressService;
114
- setProgressService(service: LearningEntityProgressService): void;
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
- declare enum EntityAccess {
118
- Preview = "preview",
119
- Full = "full"
139
+ export declare enum EntityAccess {
140
+ Preview = "preview",
141
+ Full = "full"
120
142
  }
121
- type LearningEntityAssignment = {
122
- readonly organizationKey: string;
123
- readonly levelId: number;
143
+ export type LearningEntityAssignment = {
144
+ readonly organizationKey: string;
145
+ readonly levelId: number;
124
146
  };
125
- type LearningEntityDescription = {
126
- short: string | null;
127
- full: string | null;
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
- title: string;
132
- description: LearningEntityDescription;
133
- type: {
134
- id: number;
135
- key: string;
136
- };
137
- organization: {
138
- key: string;
139
- };
140
- level: {
141
- id: number;
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
- level: {
150
- id: number;
151
- title: string;
152
- isRoot: boolean;
153
- };
154
- entity: {
155
- id: number;
156
- title: string;
157
- } | null;
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
- get id(): number;
161
- get title(): string;
162
- get description(): LearningEntityDescription;
163
- get type(): string;
164
- get levelId(): number;
165
- get organizationKey(): string;
166
- get assignment(): LearningEntityAssignment;
167
- get picture(): string | null;
168
- get icon(): string;
169
- get previous(): NextPreviousResult | null;
170
- get next(): NextPreviousResult | null;
171
- get access(): EntityAccess;
172
- getCentralService(): CentralService;
173
- setCentralService(service: CentralService): void;
174
- getLearningEntityService(): LearningEntityService;
175
- setLearningEntityService(service: LearningEntityService): void;
176
- get content(): unknown;
177
- isCheckable(): boolean;
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
- private _id;
181
- private _title;
182
- private _description;
183
- private _type;
184
- private _levelId;
185
- private _organizationKey;
186
- private _picture;
187
- private _assignment;
188
- private _previous;
189
- private _next;
190
- private _access;
191
- private _centralService;
192
- private _learningEntityService;
193
- constructor(entity: LearningEntityCommon, centralService: CentralService, learningEntityService: LearningEntityService);
194
- get id(): number;
195
- get title(): string;
196
- get description(): LearningEntityDescription;
197
- get type(): string;
198
- get levelId(): number;
199
- get organizationKey(): string;
200
- get assignment(): LearningEntityAssignment;
201
- get picture(): string | null;
202
- get previous(): NextPreviousResult | null;
203
- get next(): NextPreviousResult | null;
204
- get access(): EntityAccess;
205
- getCentralService(): CentralService;
206
- setCentralService(service: CentralService): void;
207
- getLearningEntityService(): LearningEntityService;
208
- setLearningEntityService(service: LearningEntityService): void;
209
- abstract isCheckable(): boolean;
210
- abstract get content(): unknown;
211
- abstract get icon(): string;
212
- protected abstract _init(entity: LearningEntityCommon): void;
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
- declare class EntityBottomPaneComponent {
216
- private _entity;
217
- private _evaluate;
218
- checkButtonText: string;
219
- previousButtonText: string;
220
- nextButtonText: string;
221
- constructor();
222
- get entity(): LearningEntity;
223
- set entity(entity: LearningEntity);
224
- get evaluate(): EventEmitter<void>;
225
- set evaluate(value: EventEmitter<void>);
226
- onEvaluate(): void;
227
- static ɵfac: i0.ɵɵFactoryDeclaration<EntityBottomPaneComponent, never>;
228
- static ɵcmp: i0.ɵɵComponentDeclaration<EntityBottomPaneComponent, "edyta-entity-bottom-pane", never, { "checkButtonText": { "alias": "checkButtonText"; "required": true; }; "previousButtonText": { "alias": "previousButtonText"; "required": true; }; "nextButtonText": { "alias": "nextButtonText"; "required": true; }; "entity": { "alias": "entity"; "required": true; }; }, { "evaluate": "evaluate"; }, never, never, false, never>;
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
- factId: string;
233
- optionId: string;
271
+ factId: string;
272
+ optionId: string;
234
273
  };
235
274
  declare namespace Puzzle {
236
- type Color = {
237
- requested: {
238
- background: boolean;
239
- text: boolean;
240
- };
241
- background: string;
242
- text: string;
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
- text: string;
246
- id: string;
247
- color: Color;
312
+ id: string;
313
+ text: string;
314
+ color?: Color;
248
315
  };
249
- type FactItem = Item & {
250
- assignedOptions: Item[];
316
+ type ResultItem = {
317
+ front: string;
318
+ back: string;
251
319
  };
252
- type Set = {
253
- description?: string;
254
- facts: FactItem[];
255
- options: Item[];
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 State = StateItem;
258
- type ValidationRule = State & {
259
- mandatory: boolean;
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
- private _factSelected;
309
- private _back2OptionsSection;
310
- constructor();
311
- get factSelected(): EventEmitter<Puzzle.State>;
312
- set factSelected(value: EventEmitter<Puzzle.State>);
313
- get back2OptionsSection(): EventEmitter<string>;
314
- set back2OptionsSection(value: EventEmitter<string>);
315
- onFactSelected(stateItem: Puzzle.State): void;
316
- onBack2OptionsSection(optionId: string): void;
317
- static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleOptionDialogBaseComponent, never>;
318
- static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleOptionDialogBaseComponent, "ng-component", never, {}, { "factSelected": "factSelected"; "back2OptionsSection": "back2OptionsSection"; }, never, never, false, never>;
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
- static _dependencies: {
323
- EventEmitter: {
324
- new (isAsync?: boolean): EventEmitter<any>;
325
- new <T>(isAsync?: boolean): EventEmitter<T>;
326
- readonly prototype: EventEmitter<any>;
327
- };
328
- };
329
- private _dragTargetActive;
330
- private _dropped;
331
- constructor();
332
- get dragTargetActive(): boolean;
333
- set dragTargetActive(value: boolean);
334
- get dropped(): EventEmitter<string>;
335
- onDrop(event: DragEvent): void;
336
- onDragEnter(event: DragEvent): void;
337
- onDragOver(event: DragEvent): void;
338
- onDragLeave(event: DragEvent): void;
339
- protected _emitDrop(id: string): void;
340
- static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleDropTargetComponent, never>;
341
- static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleDropTargetComponent, "ng-component", never, { "dragTargetActive": { "alias": "dragTargetActive"; "required": false; }; }, { "dropped": "dropped"; }, never, never, false, never>;
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
- declare class PuzzleLearningEntity extends InteractiveLearningEntityBase {
345
- private _content;
346
- private _progress;
347
- get icon(): string;
348
- isCheckable(): boolean;
349
- get progress(): Original.Puzzle.Progress;
350
- set progress(progress: Original.Puzzle.Progress);
351
- get content(): Puzzle.Set;
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
- private _entity;
357
- private _text;
358
- private _id;
359
- private _color;
360
- get entity(): PuzzleLearningEntity;
361
- set entity(entity: PuzzleLearningEntity);
362
- get text(): string;
363
- set text(value: string);
364
- get id(): string;
365
- set id(value: string);
366
- get color(): Puzzle.Color;
367
- set color(value: Puzzle.Color);
368
- getTextColor(color: Puzzle.Color): string | undefined;
369
- getBackgroundColor(color: Puzzle.Color): string | undefined;
370
- static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleBaseComponent, never>;
371
- static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleBaseComponent, "ng-component", never, { "entity": { "alias": "entity"; "required": true; }; "text": { "alias": "text"; "required": true; }; "id": { "alias": "id"; "required": true; }; "color": { "alias": "color"; "required": true; }; }, {}, never, never, false, never>;
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
- factId: string | undefined;
376
- optionId: string;
436
+ factId: string | undefined;
437
+ optionId: string;
377
438
  };
378
439
  declare class PuzzleFactComponent extends PuzzleBaseComponent {
379
- static _dependencies: {
380
- EventEmitter: {
381
- new (isAsync?: boolean): EventEmitter<any>;
382
- new <T>(isAsync?: boolean): EventEmitter<T>;
383
- readonly prototype: EventEmitter<any>;
384
- };
385
- };
386
- private _dropTargetActive;
387
- private _assignedOptions;
388
- private _dropped;
389
- private _dragged;
390
- assignButtonText: string;
391
- back2OptionSelectionButtonText: string;
392
- constructor();
393
- get dropTargetActive(): boolean;
394
- set dropTargetActive(value: boolean);
395
- get assignedOptions(): Puzzle.Item[];
396
- set assignedOptions(value: Puzzle.Item[]);
397
- get dropped(): EventEmitter<PuzzleDrop>;
398
- get dragged(): EventEmitter<boolean>;
399
- set dragged(value: EventEmitter<boolean>);
400
- onDropped(id: string): void;
401
- onDragged(isDragged: boolean): void;
402
- static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleFactComponent, never>;
403
- static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleFactComponent, "edyta-puzzle-fact", never, { "assignButtonText": { "alias": "assignButtonText"; "required": true; }; "back2OptionSelectionButtonText": { "alias": "back2OptionSelectionButtonText"; "required": true; }; "dropTargetActive": { "alias": "dropTargetActive"; "required": false; }; "assignedOptions": { "alias": "assignedOptions"; "required": false; }; }, { "dropped": "dropped"; "dragged": "dragged"; }, never, never, false, never>;
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
- declare class PuzzleComponent extends PuzzleDropTargetComponent {
407
- private _entity;
408
- private _puzzles;
409
- private _puzzlesOriginal;
410
- private _state;
411
- private _dropTargetActive;
412
- private _contentChange;
413
- private _evaluate;
414
- assignButtonText: string;
415
- back2OptionSelectionButtonText: string;
416
- checkButtonText: string;
417
- previousButtonText: string;
418
- nextButtonText: string;
419
- showBottomPane: boolean;
420
- constructor();
421
- get entity(): PuzzleLearningEntity;
422
- set entity(entity: PuzzleLearningEntity);
423
- get puzzles(): Puzzle.Set;
424
- set puzzles(puzzles: Puzzle.Set);
425
- get dropTargetActive(): boolean;
426
- set dropTargetActive(value: boolean);
427
- get contentChange(): EventEmitter<unknown>;
428
- set contentChange(value: EventEmitter<unknown>);
429
- get evaluate(): EventEmitter<void>;
430
- set evaluate(value: EventEmitter<void>);
431
- onDropped(puzzleDrop: PuzzleDrop): void;
432
- onDragged(isDragged: boolean): void;
433
- onFactSelected(stateItem: Puzzle.State): void;
434
- onBack2OptionsSection(optionId: string): void;
435
- onEvaluate(): void;
436
- private _process;
437
- private _applyProgress;
438
- protected _emitDrop(id: string): void;
439
- private _buildProgressSnapshot;
440
- private _stateChanged;
441
- private _recalculateState;
442
- static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleComponent, never>;
443
- static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleComponent, "edyta-puzzle", never, { "assignButtonText": { "alias": "assignButtonText"; "required": true; }; "back2OptionSelectionButtonText": { "alias": "back2OptionSelectionButtonText"; "required": true; }; "checkButtonText": { "alias": "checkButtonText"; "required": true; }; "previousButtonText": { "alias": "previousButtonText"; "required": true; }; "nextButtonText": { "alias": "nextButtonText"; "required": true; }; "showBottomPane": { "alias": "showBottomPane"; "required": false; }; "entity": { "alias": "entity"; "required": true; }; }, { "contentChange": "contentChange"; "evaluate": "evaluate"; }, never, never, false, never>;
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
- private _entity;
448
- private _text;
449
- private _id;
450
- private _dropTargetActive;
451
- private _assignedOptions;
452
- private _dragged;
453
- assignButtonText: string;
454
- back2OptionSelectionButtonText: string;
455
- constructor();
456
- get entity(): PuzzleLearningEntity;
457
- set entity(entity: PuzzleLearningEntity);
458
- get text(): string;
459
- set text(value: string);
460
- get id(): string;
461
- set id(value: string);
462
- get dropTargetActive(): boolean;
463
- set dropTargetActive(value: boolean);
464
- get assignedOptions(): Puzzle.Item[];
465
- set assignedOptions(value: Puzzle.Item[]);
466
- get dragged(): EventEmitter<boolean>;
467
- set dragged(value: EventEmitter<boolean>);
468
- onDragged(isDragged: boolean): void;
469
- static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleTargetComponent, never>;
470
- static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleTargetComponent, "edyta-puzzle-target", never, { "assignButtonText": { "alias": "assignButtonText"; "required": true; }; "back2OptionSelectionButtonText": { "alias": "back2OptionSelectionButtonText"; "required": true; }; "entity": { "alias": "entity"; "required": true; }; "text": { "alias": "text"; "required": false; }; "id": { "alias": "id"; "required": false; }; "dropTargetActive": { "alias": "dropTargetActive"; "required": false; }; "assignedOptions": { "alias": "assignedOptions"; "required": false; }; }, { "dragged": "dragged"; }, never, never, false, never>;
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
- static _dependencies: {
475
- EventEmitter: {
476
- new (isAsync?: boolean): EventEmitter<any>;
477
- new <T>(isAsync?: boolean): EventEmitter<T>;
478
- readonly prototype: EventEmitter<any>;
479
- };
480
- };
481
- assignButtonText: string;
482
- back2OptionSelectionButtonText: string;
483
- private _back2OptionsSectionMode;
484
- private _dragIsActive;
485
- private _dragged;
486
- constructor();
487
- get back2OptionsSectionMode(): boolean;
488
- set back2OptionsSectionMode(value: boolean);
489
- get dragIsActive(): boolean;
490
- set dragIsActive(value: boolean);
491
- get dragged(): EventEmitter<boolean>;
492
- onDragStart(event: DragEvent): void;
493
- onDragEnd(): void;
494
- static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleOptionComponent, never>;
495
- static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleOptionComponent, "edyta-puzzle-option", never, { "assignButtonText": { "alias": "assignButtonText"; "required": true; }; "back2OptionSelectionButtonText": { "alias": "back2OptionSelectionButtonText"; "required": true; }; "back2OptionsSectionMode": { "alias": "back2OptionsSectionMode"; "required": false; }; }, { "dragged": "dragged"; }, never, never, false, never>;
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
- private _entity;
500
- private _text;
501
- private _id;
502
- private _selectedFactId;
503
- private _back2OptionsSectionMode;
504
- assignButtonText: string;
505
- back2OptionSelectionButtonText: string;
506
- get entity(): PuzzleLearningEntity;
507
- set entity(entity: PuzzleLearningEntity);
508
- get text(): string;
509
- set text(value: string);
510
- get id(): string;
511
- set id(value: string);
512
- get back2OptionsSectionMode(): boolean;
513
- set back2OptionsSectionMode(value: boolean);
514
- get selectedFactId(): string;
515
- set selectedFactId(value: string);
516
- onFactSelected(): void;
517
- onBack2OptionsSection(): void;
518
- static ɵfac: i0.ɵɵFactoryDeclaration<PuzzleOptionDialogComponent, never>;
519
- static ɵcmp: i0.ɵɵComponentDeclaration<PuzzleOptionDialogComponent, "[edyta-puzzle-option-dialog]", never, { "assignButtonText": { "alias": "assignButtonText"; "required": true; }; "back2OptionSelectionButtonText": { "alias": "back2OptionSelectionButtonText"; "required": true; }; "entity": { "alias": "entity"; "required": true; }; "text": { "alias": "text"; "required": true; }; "id": { "alias": "id"; "required": true; }; "back2OptionsSectionMode": { "alias": "back2OptionsSectionMode"; "required": false; }; }, {}, never, never, false, never>;
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
- enum PicturePosition {
524
- Left = "left",
525
- Right = "right"
526
- }
527
- type Media = {
528
- url: string;
529
- mimeType: string;
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
- type Item = {
532
- key: string;
533
- color?: {
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
- declare class GrammarLearningEntity extends LearningEntityBase {
555
- private _grammars;
556
- get icon(): string;
557
- isCheckable(): boolean;
558
- get content(): Grammar.Items;
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
- declare class GrammarComponent extends CanvasComponent {
563
- private _entity;
564
- get entity(): GrammarLearningEntity;
565
- set entity(entity: GrammarLearningEntity);
566
- static ɵfac: i0.ɵɵFactoryDeclaration<GrammarComponent, never>;
567
- static ɵcmp: i0.ɵɵComponentDeclaration<GrammarComponent, "edyta-grammar", never, { "entity": { "alias": "entity"; "required": true; }; }, {}, never, never, false, never>;
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
- export enum FrontCardTitleVisibilityMode {
572
- Visible = "visible",
573
- Blurred = "blurred",
574
- Invisible = "invisible"
575
- }
576
- type Meaning = {
577
- lang: string;
578
- text: string;
579
- };
580
- type Description = {
581
- lang: string;
582
- text: string;
583
- };
584
- export type Item = {
585
- key: string;
586
- meaning: Meaning[];
587
- flip?: boolean;
588
- description: Description[];
589
- picture?: string;
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
- export type Content = {
592
- lang: string;
593
- shuffle?: boolean;
594
- shuffleButtonVisible?: boolean;
595
- frontCardTitleVisibilityMode?: FrontCardTitleVisibilityMode;
596
- input: Item[];
833
+ "visibilityButtonHideTitleText": {
834
+ "alias": "visibilityButtonHideTitleText";
835
+ "required": true;
597
836
  };
598
- export type Set = LearningEntityCommon & {
599
- content: Content;
837
+ "shuffleButtonText": {
838
+ "alias": "shuffleButtonText";
839
+ "required": true;
600
840
  };
601
- export type TransformedItem = {
602
- key: string;
603
- meaning?: string;
604
- flip?: boolean;
605
- description?: string;
606
- picture?: string;
841
+ "entity": {
842
+ "alias": "entity";
843
+ "required": true;
607
844
  };
608
- export type TransformedItems = TransformedItem[];
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
- type Option = {
654
- id: string;
655
- text: string;
656
- };
657
- type Media = {
658
- url: string;
659
- mimeType: string;
660
- };
661
- type Picture = {
662
- url: string;
663
- alwaysVisible?: boolean;
664
- };
665
- type GenericInput = {
666
- key: string;
667
- type: string;
668
- text: string;
669
- description?: string;
670
- divider?: boolean;
671
- media?: Media;
672
- picture?: Picture | string;
673
- color?: {
674
- background?: string;
675
- text?: string;
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
- type ResultItem = {
721
- key: string;
722
- correct: string[] | string;
723
- optional?: string[] | string;
724
- };
725
- type Result = ResultItem[];
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
- declare class FormLearningEntity extends InteractiveLearningEntityBase {
729
- private _content;
730
- private _progress;
731
- get icon(): string;
732
- isCheckable(): boolean;
733
- get progress(): Form.Progress;
734
- set progress(progress: Form.Progress);
735
- get content(): Form.Items;
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
- declare class FormComponent extends CanvasComponent {
740
- private _entity;
741
- private _formItems;
742
- constructor();
743
- get entity(): FormLearningEntity;
744
- set entity(entity: FormLearningEntity);
745
- get formItems(): Form.Items;
746
- set formItems(form: Form.Items);
747
- onChange(): void;
748
- private _process;
749
- private _prepareState;
750
- private _buildProgressSnapshot;
751
- private _applyProgress2State;
752
- static ɵfac: i0.ɵɵFactoryDeclaration<FormComponent, never>;
753
- static ɵcmp: i0.ɵɵComponentDeclaration<FormComponent, "edyta-form", never, { "entity": { "alias": "entity"; "required": true; }; }, {}, never, never, false, never>;
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
- static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeTextComponent, never>;
758
- static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeTextComponent, "edyta-form-type-text", never, {}, {}, never, never, false, never>;
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
- private _content;
763
- get content(): Form.Input;
764
- set content(value: Form.Input);
765
- onChange(): void;
766
- static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeInputComponent, never>;
767
- static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeInputComponent, "edyta-form-type-input", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, false, never>;
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
- private _content;
772
- get content(): Form.Select;
773
- set content(value: Form.Select);
774
- onChange(): void;
775
- static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeSelectComponent, never>;
776
- static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeSelectComponent, "edyta-form-type-select", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, false, never>;
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
- private _content;
781
- get content(): Form.Radio;
782
- set content(value: Form.Radio);
783
- onChange(): void;
784
- static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeRadioComponent, never>;
785
- static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeRadioComponent, "edyta-form-type-radio", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, false, never>;
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
- private _content;
790
- get content(): Form.Checkbox;
791
- set content(value: Form.Checkbox);
792
- onChange(): void;
793
- static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeCheckboxComponent, never>;
794
- static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeCheckboxComponent, "edyta-form-type-checkbox", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, false, never>;
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
- private _content;
799
- get content(): Form.Date;
800
- set content(value: Form.Date);
801
- onChange(): void;
802
- static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeDateComponent, never>;
803
- static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeDateComponent, "edyta-form-type-date", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, false, never>;
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
- content: Form.UkuleleChord;
808
- static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeUkuleleChordsComponent, never>;
809
- static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeUkuleleChordsComponent, "edyta-form-type-ukulele-chords", never, { "content": { "alias": "content"; "required": true; }; }, {}, never, never, false, never>;
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
- private _content;
814
- get content(): Form.Input | Form.Text | Form.Checkbox | Form.Date | Form.Radio | Form.Select;
815
- set content(value: Form.Input | Form.Text | Form.Checkbox | Form.Date | Form.Radio | Form.Select);
816
- showDecriptionSection(): boolean;
817
- showMedia(): boolean;
818
- showPicture(): boolean;
819
- isPictureAlwaysVisible(): boolean;
820
- onChange(): void;
821
- static ɵfac: i0.ɵɵFactoryDeclaration<FormTypeItemComponent, never>;
822
- static ɵcmp: i0.ɵɵComponentDeclaration<FormTypeItemComponent, "edyta-form-type-item", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, false, never>;
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
- private _vocabulary;
827
- private _frontCardTitleVisibilityMode;
828
- private _titleIsVisible;
829
- get vocabulary(): Vocabulary.TransformedItem;
830
- set vocabulary(value: Vocabulary.TransformedItem);
831
- get frontCardTitleVisibilityMode(): Vocabulary.FrontCardTitleVisibilityMode;
832
- set frontCardTitleVisibilityMode(mode: Vocabulary.FrontCardTitleVisibilityMode);
833
- get titleIsVisible(): boolean;
834
- set titleIsVisible(visible: boolean);
835
- calculateHtmlClasses4Title(): {
836
- 'card__face-front-blur'?: undefined;
837
- 'card__face-front-invisible'?: undefined;
838
- } | {
839
- 'card__face-front-blur': boolean;
840
- 'card__face-front-invisible': boolean;
841
- };
842
- static ɵfac: i0.ɵɵFactoryDeclaration<VocabularyCardBaseComponent, never>;
843
- static ɵcmp: i0.ɵɵComponentDeclaration<VocabularyCardBaseComponent, "ng-component", never, { "vocabulary": { "alias": "vocabulary"; "required": true; }; "frontCardTitleVisibilityMode": { "alias": "frontCardTitleVisibilityMode"; "required": true; }; "titleIsVisible": { "alias": "titleIsVisible"; "required": false; }; }, {}, never, never, false, never>;
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
- private _flipped;
848
- get flipped(): boolean;
849
- set flipped(value: boolean);
850
- onToggleFlip(): void;
851
- get descriptionImageUrl(): string | null;
852
- static ɵfac: i0.ɵɵFactoryDeclaration<VocabularyCardFlipComponent, never>;
853
- static ɵcmp: i0.ɵɵComponentDeclaration<VocabularyCardFlipComponent, "edyta-vocabulary-card-flip", never, {}, {}, never, never, false, never>;
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
- static ɵfac: i0.ɵɵFactoryDeclaration<VocabularyCardStandardComponent, never>;
858
- static ɵcmp: i0.ɵɵComponentDeclaration<VocabularyCardStandardComponent, "edyta-vocabulary-card-standard", never, {}, {}, never, never, false, never>;
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
- content: Grammar.Item;
863
- showMedia(): boolean;
864
- showPictureOnLeft(): boolean;
865
- showPictureOnRight(): boolean;
866
- static ɵfac: i0.ɵɵFactoryDeclaration<GrammarItemComponent, never>;
867
- static ɵcmp: i0.ɵɵComponentDeclaration<GrammarItemComponent, "edyta-grammar-item", never, { "content": { "alias": "content"; "required": false; }; }, {}, never, never, false, never>;
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
- type Media = {
872
- url: string;
873
- mimeType: string;
874
- };
875
- type Option = {
876
- id: string;
877
- text: string;
878
- };
879
- type GenericInput = {
880
- key: string;
881
- type: string;
882
- options?: Option[];
883
- };
884
- type Input = GenericInput & {
885
- state: string;
886
- };
887
- type Select = Input & {
888
- options: Option[];
889
- };
890
- type ResultItem = {
891
- key: string;
892
- correct: string[] | string;
893
- };
894
- type Result = ResultItem[];
895
- type ProgressItem = {
896
- key: string;
897
- state: string;
898
- };
899
- type Progress = ProgressItem[] | null | undefined;
900
- type Items = (Input | Select)[];
901
- type Content = {
902
- type: string;
903
- title: string;
904
- innerHTML: string;
905
- media: Media;
906
- lang: string;
907
- input: Items;
908
- };
909
- type Set = LearningEntityCommon & {
910
- content: Content;
911
- progress: Progress;
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
- declare class RiddleLearningEntity extends InteractiveLearningEntityBase {
916
- private _content;
917
- private _progress;
918
- get icon(): string;
919
- isCheckable(): boolean;
920
- get progress(): Riddle.Progress;
921
- set progress(progress: Riddle.Progress);
922
- get content(): Riddle.Content;
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
- declare class RiddleComponent extends CanvasComponent implements AfterViewChecked {
927
- private _sanitizer;
928
- private _router;
929
- private _html;
930
- private _entity;
931
- private _eventListenerAdded;
932
- errorReceived: EventEmitter<Error>;
933
- constructor(_sanitizer: DomSanitizer, _router: Router);
934
- ngAfterViewChecked(): void;
935
- get entity(): RiddleLearningEntity;
936
- set entity(entity: RiddleLearningEntity);
937
- get html(): SafeHtml;
938
- set html(value: SafeHtml);
939
- private _process;
940
- private _prepareState;
941
- private _applyProgress2State;
942
- private _deriveRiddleItemByElement;
943
- private _determineHTMLEvent;
944
- private _isEventListenerAdded;
945
- private _buildProgressSnapshot;
946
- static ɵfac: i0.ɵɵFactoryDeclaration<RiddleComponent, never>;
947
- static ɵcmp: i0.ɵɵComponentDeclaration<RiddleComponent, "edyta-riddle", never, { "entity": { "alias": "entity"; "required": true; }; }, { "errorReceived": "errorReceived"; }, never, never, false, never>;
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
- type Media = {
952
- url: string;
953
- mimeType: string;
954
- };
955
- type ResultItem = {
956
- key: string;
957
- question: string;
958
- answer: string;
959
- };
960
- type ProgressItem = {
961
- key: string;
962
- answer: boolean | undefined;
963
- };
964
- type Progress = ProgressItem[] | null | undefined;
965
- type ResultItems = ResultItem[];
966
- type Content = {
967
- type: string;
968
- title: string;
969
- innerHTML: string;
970
- media?: Media;
971
- lang: string;
972
- input: ResultItems;
973
- };
974
- type Set = LearningEntityCommon & {
975
- content: Content;
976
- progress: Progress;
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
- declare class YesNoLearningEntity extends InteractiveLearningEntityBase {
981
- private _content;
982
- private _progress;
983
- get icon(): string;
984
- isCheckable(): boolean;
985
- get progress(): YesNo.Progress;
986
- set progress(progress: YesNo.Progress);
987
- get content(): YesNo.Content;
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
- declare class YesnoComponent extends CanvasComponent {
992
- private _entity;
993
- get entity(): YesNoLearningEntity;
994
- set entity(entity: YesNoLearningEntity);
995
- onChange(): void;
996
- showMedia(): boolean;
997
- private _process;
998
- private _prepareState;
999
- private _applyProgress2State;
1000
- private buildProgressSnapshot;
1001
- private calculateAnswer;
1002
- static ɵfac: i0.ɵɵFactoryDeclaration<YesnoComponent, never>;
1003
- static ɵcmp: i0.ɵɵComponentDeclaration<YesnoComponent, "edyta-yes-no", never, { "entity": { "alias": "entity"; "required": true; }; }, {}, never, never, false, never>;
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
- private readonly document;
1008
- html: string;
1009
- set edytaAlignedHtml(value: string | null | undefined);
1010
- static ɵfac: i0.ɵɵFactoryDeclaration<AlignedHtmlDirective, never>;
1011
- static ɵdir: i0.ɵɵDirectiveDeclaration<AlignedHtmlDirective, "[edytaAlignedHtml]", never, { "edytaAlignedHtml": { "alias": "edytaAlignedHtml"; "required": false; }; }, {}, never, never, true, never>;
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
- declare class CanvasModule {
1015
- static ɵfac: i0.ɵɵFactoryDeclaration<CanvasModule, never>;
1016
- 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]>;
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
- declare class LearningEntityFactory {
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 {};