diff --git a/src/lib/mocks/index.ts b/src/lib/mocks/index.ts index ec008fa2..ea245b49 100644 --- a/src/lib/mocks/index.ts +++ b/src/lib/mocks/index.ts @@ -3,6 +3,7 @@ import { CSS_IDS, CSS_TEMPLATES } from './css'; import { calculateTotalPoints, shuffleOptions } from './utils'; import type { ExerciseTemplate } from '$lib/utils/types'; import { JS_IDS, JS_TEMPLATES } from './js'; +import { TS_IDS, TS_TEMPLATES } from './typescript'; export const TAGS = { HTML: 'HTML', @@ -43,7 +44,7 @@ export const TEMPLATES = { [TAGS.HTML]: generateTemplateForTag(HTML_IDS, HTML_TEMPLATES), [TAGS.CSS]: generateTemplateForTag(CSS_IDS, CSS_TEMPLATES), [TAGS.JS]: generateTemplateForTag(JS_IDS, JS_TEMPLATES), - [TAGS.Typescript]: [], + [TAGS.Typescript]: generateTemplateForTag(TS_IDS, TS_TEMPLATES), [TAGS.ReactJS]: [], [TAGS.VueJS]: [] }; diff --git a/src/lib/mocks/typescript/001_ts_simpleTypes.ts b/src/lib/mocks/typescript/001_ts_simpleTypes.ts new file mode 100644 index 00000000..af6e19a8 --- /dev/null +++ b/src/lib/mocks/typescript/001_ts_simpleTypes.ts @@ -0,0 +1,228 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Simple Types Quiz', + description: 'Test your knowledge of TypeScript simple types.', + questionnaire: { + questions: [ + { + title: 'What is the TypeScript type for representing a string?', + name: 'q1', + points: 1, + order: 1, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'str', + is_correct: false + }, + { + label: 'string', + is_correct: true + }, + { + label: 'text', + is_correct: false + } + ] + }, + { + title: 'Which keyword is used to declare a constant in TypeScript?', + name: 'q2', + points: 1, + order: 2, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'let', + is_correct: false + }, + { + label: 'const', + is_correct: true + }, + { + label: 'var', + is_correct: false + } + ] + }, + { + title: 'What is the TypeScript type for representing a boolean value?', + name: 'q3', + points: 1, + order: 3, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'bool', + is_correct: false + }, + { + label: 'boolean', + is_correct: true + }, + { + label: 'truefalse', + is_correct: false + } + ] + }, + { + title: 'Which TypeScript type can hold multiple values, such as a list of numbers?', + name: 'q4', + points: 1, + order: 4, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'array', + is_correct: false + }, + { + label: 'number[]', + is_correct: true + }, + { + label: 'list', + is_correct: false + } + ] + }, + { + title: 'What is the TypeScript type for representing a function?', + name: 'q5', + points: 1, + order: 5, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'function', + is_correct: false + }, + { + label: 'func', + is_correct: false + }, + { + label: '() => void', + is_correct: true + } + ] + }, + { + title: 'Which TypeScript type represents a value that can be either a number or a string?', + name: 'q6', + points: 1, + order: 6, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'number|string', + is_correct: true + }, + { + label: 'mixed', + is_correct: false + }, + { + label: 'any', + is_correct: false + } + ] + }, + { + title: 'In TypeScript, how do you declare a variable without specifying its type?', + name: 'q7', + points: 1, + order: 7, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Using the `var` keyword', + is_correct: false + }, + { + label: 'Using the `let` keyword', + is_correct: false + }, + { + label: 'Using the `const` keyword', + is_correct: false + }, + { + label: 'Using the `any` keyword', + is_correct: true + } + ] + }, + { + title: 'Which TypeScript type represents a value that can be null or undefined?', + name: 'q8', + points: 1, + order: 8, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'null', + is_correct: false + }, + { + label: 'undefined', + is_correct: false + }, + { + label: 'null|undefined', + is_correct: true + } + ] + }, + { + title: 'What is the TypeScript type for representing an object with specific properties?', + name: 'q9', + points: 1, + order: 9, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'object', + is_correct: false + }, + { + label: 'Record', + is_correct: false + }, + { + label: 'Custom interface/type', + is_correct: true + } + ] + }, + { + title: 'Which TypeScript type can be used to represent a value that is not available yet or an error?', + name: 'q10', + points: 1, + order: 10, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'unknown', + is_correct: true + }, + { + label: 'undefined', + is_correct: false + }, + { + label: 'null', + is_correct: false + } + ] + } + ] + } +}; + +export default template; diff --git a/src/lib/mocks/typescript/002_ts_specialTypes.ts b/src/lib/mocks/typescript/002_ts_specialTypes.ts new file mode 100644 index 00000000..cf7ef412 --- /dev/null +++ b/src/lib/mocks/typescript/002_ts_specialTypes.ts @@ -0,0 +1,304 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Special Types Quiz', + description: 'Test your knowledge of TypeScript special types.', + questionnaire: { + questions: [ + { + title: 'What is the special type for defining a variable that may have a null value?', + name: 'q1', + points: 1, + order: 1, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Nullable', + is_correct: false + }, + { + label: 'Optional', + is_correct: false + }, + { + label: 'null', + is_correct: false + }, + { + label: 'undefined', + is_correct: false + }, + { + label: 'nullish', + is_correct: true + } + ] + }, + { + title: 'Which special type represents a collection of unique values?', + name: 'q2', + points: 1, + order: 2, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'UniqueSet', + is_correct: false + }, + { + label: 'UniqueArray', + is_correct: false + }, + { + label: 'Tuple', + is_correct: false + }, + { + label: 'Enum', + is_correct: true + }, + { + label: 'Record', + is_correct: false + } + ] + }, + { + title: 'What special type is used to represent a function that never returns?', + name: 'q3', + points: 1, + order: 3, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Void', + is_correct: false + }, + { + label: 'Never', + is_correct: true + }, + { + label: 'None', + is_correct: false + }, + { + label: 'Undefined', + is_correct: false + }, + { + label: 'Null', + is_correct: false + } + ] + }, + { + title: 'Which special type is used for specifying that a variable can be of multiple types?', + name: 'q4', + points: 1, + order: 4, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Any', + is_correct: false + }, + { + label: 'Union', + is_correct: true + }, + { + label: 'Intersection', + is_correct: false + }, + { + label: 'Variant', + is_correct: false + }, + { + label: 'Multiple', + is_correct: false + } + ] + }, + { + title: 'Which special type represents a property of an object?', + name: 'q5', + points: 1, + order: 5, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Member', + is_correct: false + }, + { + label: 'Property', + is_correct: false + }, + { + label: 'Field', + is_correct: true + }, + { + label: 'Attribute', + is_correct: false + }, + { + label: 'Variable', + is_correct: false + } + ] + }, + { + title: 'Which special type is used for defining the shape of an object?', + name: 'q6', + points: 1, + order: 6, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'ObjectType', + is_correct: false + }, + { + label: 'ShapeType', + is_correct: false + }, + { + label: 'Interface', + is_correct: true + }, + { + label: 'ObjectShape', + is_correct: false + }, + { + label: 'Struct', + is_correct: false + } + ] + }, + { + title: 'Which special type is used for defining a key-value pair object?', + name: 'q7', + points: 1, + order: 7, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Record', + is_correct: true + }, + { + label: 'Map', + is_correct: false + }, + { + label: 'Dictionary', + is_correct: false + }, + { + label: 'KeyValuePair', + is_correct: false + }, + { + label: 'Object', + is_correct: false + } + ] + }, + { + title: 'Which special type is used for defining a variable with a default value?', + name: 'q8', + points: 1, + order: 8, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'DefaultValue', + is_correct: false + }, + { + label: 'Default', + is_correct: false + }, + { + label: 'InitialValue', + is_correct: false + }, + { + label: 'Value', + is_correct: false + }, + { + label: 'DefaultType', + is_correct: true + } + ] + }, + { + title: 'What is the special type used for representing a value that may be either a specified type or null or undefined?', + name: 'q9', + points: 1, + order: 9, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'NullableType', + is_correct: false + }, + { + label: 'OptionalType', + is_correct: false + }, + { + label: 'MixedType', + is_correct: false + }, + { + label: 'UnknownType', + is_correct: false + }, + { + label: 'NullableTypeUnion', + is_correct: true + } + ] + }, + { + title: 'What special type represents a value that is the result of a computation that may fail?', + name: 'q10', + points: 1, + order: 10, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Result', + is_correct: true + }, + { + label: 'Outcome', + is_correct: false + }, + { + label: 'Error', + is_correct: false + }, + { + label: 'Fail', + is_correct: false + }, + { + label: 'Unsafe', + is_correct: false + } + ] + } + ] + } +}; + +export default template; diff --git a/src/lib/mocks/typescript/003_ts_arrays.ts b/src/lib/mocks/typescript/003_ts_arrays.ts new file mode 100644 index 00000000..bf1a8b77 --- /dev/null +++ b/src/lib/mocks/typescript/003_ts_arrays.ts @@ -0,0 +1,304 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Arrays Quiz', + description: 'Test your knowledge of TypeScript arrays.', + questionnaire: { + questions: [ + { + title: 'What is the correct way to declare an array in TypeScript?', + name: 'q1', + points: 1, + order: 1, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'let array = []', + is_correct: false + }, + { + label: 'const array = {}', + is_correct: false + }, + { + label: 'const array: Array = []', + is_correct: true + }, + { + label: 'const array: number[] = {}', + is_correct: false + }, + { + label: 'let array = new Array()', + is_correct: false + } + ] + }, + { + title: 'What method is used to add new elements to the end of an array in TypeScript?', + name: 'q2', + points: 1, + order: 2, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'push()', + is_correct: true + }, + { + label: 'add()', + is_correct: false + }, + { + label: 'append()', + is_correct: false + }, + { + label: 'insert()', + is_correct: false + }, + { + label: 'concat()', + is_correct: false + } + ] + }, + { + title: 'How do you access the first element of an array in TypeScript?', + name: 'q3', + points: 1, + order: 3, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'array[0]', + is_correct: true + }, + { + label: 'array.first()', + is_correct: false + }, + { + label: 'array.first', + is_correct: false + }, + { + label: 'array.getElement(0)', + is_correct: false + }, + { + label: 'array.front()', + is_correct: false + } + ] + }, + { + title: 'What TypeScript method is used to remove the last element from an array and return that element?', + name: 'q4', + points: 1, + order: 4, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'shift()', + is_correct: false + }, + { + label: 'pop()', + is_correct: true + }, + { + label: 'removeLast()', + is_correct: false + }, + { + label: 'slice()', + is_correct: false + }, + { + label: 'splice()', + is_correct: false + } + ] + }, + { + title: 'What is the result of the following code?\n\n```typescript\nconst numbers = [1, 2, 3, 4, 5];\nconst slicedNumbers = numbers.slice(1, 3);\nconsole.log(slicedNumbers);\n```', + name: 'q5', + points: 1, + order: 5, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: '[1, 2, 3]', + is_correct: false + }, + { + label: '[2, 3]', + is_correct: true + }, + { + label: '[3, 4]', + is_correct: false + }, + { + label: '[2, 4]', + is_correct: false + }, + { + label: '[1, 3]', + is_correct: false + } + ] + }, + { + title: 'In TypeScript, how can you check if an element exists in an array?', + name: 'q6', + points: 1, + order: 6, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Use the `elementOf` operator', + is_correct: false + }, + { + label: 'Use the `contains` method', + is_correct: false + }, + { + label: 'Use the `includes` method', + is_correct: true + }, + { + label: 'Use the `has` method', + is_correct: false + }, + { + label: 'Use the `find` method', + is_correct: false + } + ] + }, + { + title: 'Which TypeScript method is used to join all elements of an array into a string?', + name: 'q7', + points: 1, + order: 7, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'join()', + is_correct: true + }, + { + label: 'concat()', + is_correct: false + }, + { + label: 'merge()', + is_correct: false + }, + { + label: 'combine()', + is_correct: false + }, + { + label: 'implode()', + is_correct: false + } + ] + }, + { + title: 'What is the correct way to remove an element by index from an array in TypeScript?', + name: 'q8', + points: 1, + order: 8, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Use the `remove` method', + is_correct: false + }, + { + label: 'Use the `splice` method', + is_correct: true + }, + { + label: 'Use the `delete` operator', + is_correct: false + }, + { + label: 'Use the `filter` method', + is_correct: false + }, + { + label: 'Use the `discard` method', + is_correct: false + } + ] + }, + { + title: 'What is the correct TypeScript syntax to sort an array in descending order?', + name: 'q9', + points: 1, + order: 9, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'array.sort()', + is_correct: false + }, + { + label: 'array.sort((a, b) => b - a)', + is_correct: true + }, + { + label: 'array.reverse()', + is_correct: false + }, + { + label: 'array.sort((a, b) => a - b)', + is_correct: false + }, + { + label: 'array.descending()', + is_correct: false + } + ] + }, + { + title: 'Which TypeScript method is used to add one or more elements to the beginning of an array?', + name: 'q10', + points: 1, + order: 10, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'prepend()', + is_correct: false + }, + { + label: 'unshift()', + is_correct: true + }, + { + label: 'push()', + is_correct: false + }, + { + label: 'addFirst()', + is_correct: false + }, + { + label: 'insertAtStart()', + is_correct: false + } + ] + } + ] + } +}; + +export default template; diff --git a/src/lib/mocks/typescript/004_ts_tuples.ts b/src/lib/mocks/typescript/004_ts_tuples.ts new file mode 100644 index 00000000..61c85aa6 --- /dev/null +++ b/src/lib/mocks/typescript/004_ts_tuples.ts @@ -0,0 +1,264 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Tuples Quiz', + description: 'Test your knowledge of TypeScript tuples.', + questionnaire: { + questions: [ + { + title: 'What is a TypeScript tuple?', + name: 'q1', + points: 1, + order: 1, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A data structure that stores a fixed-size collection of elements of mixed types.', + is_correct: true + }, + { + label: 'A data structure that stores an unlimited number of elements of the same type.', + is_correct: false + }, + { + label: 'A data structure that stores elements of the same type and size.', + is_correct: false + }, + { + label: 'A data structure that stores elements of mixed types without size restrictions.', + is_correct: false + } + ] + }, + { + title: 'How do you define a tuple type in TypeScript?', + name: 'q2', + points: 1, + order: 2, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Using the `Tuple` keyword', + is_correct: false + }, + { + label: 'Using the `tuple` keyword', + is_correct: true + }, + { + label: 'Using the `array` keyword', + is_correct: false + }, + { + label: 'Using the `list` keyword', + is_correct: false + } + ] + }, + { + title: 'How can you access elements of a TypeScript tuple?', + name: 'q3', + points: 1, + order: 3, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'By using the dot notation (e.g., `tuple.0`)', + is_correct: false + }, + { + label: 'By using square brackets (e.g., `tuple[0]`)', + is_correct: true + }, + { + label: 'By using parentheses (e.g., `tuple(0)`)', + is_correct: false + }, + { + label: 'By using the `get` method (e.g., `tuple.get(0)`)', + is_correct: false + } + ] + }, + { + title: 'Which of the following statements is true about TypeScript tuples?', + name: 'q4', + points: 1, + order: 4, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Tuples allow elements to be added or removed dynamically.', + is_correct: false + }, + { + label: 'Tuples can contain elements of different types but must be of fixed size.', + is_correct: true + }, + { + label: 'Tuples are resizable arrays with dynamic types.', + is_correct: false + }, + { + label: 'Tuples can only contain elements of the same type.', + is_correct: false + } + ] + }, + { + title: 'What is the correct way to initialize a TypeScript tuple?', + name: 'q5', + points: 1, + order: 5, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'const myTuple: tuple = [1, "two", 3]', + is_correct: false + }, + { + label: 'const myTuple: [number, string, number] = [1, "two", 3]', + is_correct: true + }, + { + label: 'const myTuple: (number, string, number) = [1, "two", 3]', + is_correct: false + }, + { + label: 'const myTuple: tuple = [1, "two", 3]', + is_correct: false + } + ] + }, + { + title: 'In a TypeScript tuple, what does the number in the tuple type represent?', + name: 'q6', + points: 1, + order: 6, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'The maximum number of elements that the tuple can hold.', + is_correct: true + }, + { + label: 'The index of the first element in the tuple.', + is_correct: false + }, + { + label: 'The type of the elements in the tuple.', + is_correct: false + }, + { + label: 'The size of the tuple in memory.', + is_correct: false + } + ] + }, + { + title: 'How do you update a value in a TypeScript tuple?', + name: 'q7', + points: 1, + order: 7, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'You cannot update values in a tuple; tuples are immutable.', + is_correct: true + }, + { + label: 'By using the `update` method on the tuple.', + is_correct: false + }, + { + label: 'By directly assigning a new value to the tuple element.', + is_correct: false + }, + { + label: 'By using the `set` method on the tuple.', + is_correct: false + } + ] + }, + { + title: 'What is the advantage of using TypeScript tuples over arrays?', + name: 'q8', + points: 1, + order: 8, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Tuples have a dynamic size, making them more flexible.', + is_correct: false + }, + { + label: 'Tuples allow you to store elements of different types.', + is_correct: true + }, + { + label: 'Tuples have better performance for iteration.', + is_correct: false + }, + { + label: 'Tuples provide built-in sorting methods.', + is_correct: false + } + ] + }, + { + title: 'Can TypeScript tuples be used to represent key-value pairs?', + name: 'q9', + points: 1, + order: 9, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Yes, by using the `key` and `value` properties of a tuple element.', + is_correct: false + }, + { + label: 'Yes, by using tuples with two elements where the first element is the key and the second element is the value.', + is_correct: true + }, + { + label: 'No, tuples are not suitable for representing key-value pairs.', + is_correct: false + }, + { + label: 'No, TypeScript does not support key-value pairs in tuples.', + is_correct: false + } + ] + }, + { + title: 'Which TypeScript version introduced tuple types?', + name: 'q10', + points: 1, + order: 10, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'TypeScript has always had tuple types.', + is_correct: false + }, + { + label: 'TypeScript 2.0', + is_correct: true + }, + { + label: 'TypeScript 3.0', + is_correct: false + }, + { + label: 'TypeScript 4.0', + is_correct: false + } + ] + } + ] + } +}; + +export default template; diff --git a/src/lib/mocks/typescript/005_ts_objectTypes.ts b/src/lib/mocks/typescript/005_ts_objectTypes.ts new file mode 100644 index 00000000..1def30f0 --- /dev/null +++ b/src/lib/mocks/typescript/005_ts_objectTypes.ts @@ -0,0 +1,264 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Object Types Quiz', + description: 'Test your knowledge of TypeScript object types.', + questionnaire: { + questions: [ + { + title: 'What is an object type in TypeScript?', + name: 'q1', + points: 1, + order: 1, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A type that represents a single value, such as a number or string.', + is_correct: false + }, + { + label: 'A type that represents a collection of key-value pairs.', + is_correct: true + }, + { + label: 'A type that represents an array of values.', + is_correct: false + }, + { + label: 'A type that represents a function.', + is_correct: false + } + ] + }, + { + title: 'How do you define an object type in TypeScript?', + name: 'q2', + points: 1, + order: 2, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Using the `object` keyword.', + is_correct: false + }, + { + label: 'Using the `type` keyword with key-value pairs.', + is_correct: true + }, + { + label: 'Using the `class` keyword.', + is_correct: false + }, + { + label: 'Using the `interface` keyword.', + is_correct: false + } + ] + }, + { + title: 'What does the following TypeScript object type definition represent?\n\n```\ntype Person = {\n name: string;\n age: number;\n};\n```', + name: 'q3', + points: 1, + order: 3, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A function type that takes a name and age as arguments and returns a string.', + is_correct: false + }, + { + label: 'An object type with properties `name` and `age`, where `name` is a string and `age` is a number.', + is_correct: true + }, + { + label: 'A class definition for creating `Person` instances.', + is_correct: false + }, + { + label: 'An array type that contains `Person` objects.', + is_correct: false + } + ] + }, + { + title: 'What is the purpose of using optional properties in TypeScript object types?', + name: 'q4', + points: 1, + order: 4, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'To indicate that a property is required and must have a value.', + is_correct: false + }, + { + label: 'To indicate that a property is optional and may have a value or be undefined.', + is_correct: true + }, + { + label: 'To indicate that a property should not be accessed.', + is_correct: false + }, + { + label: 'To indicate that a property is a function.', + is_correct: false + } + ] + }, + { + title: 'What is the correct way to access properties of an object type in TypeScript?', + name: 'q5', + points: 1, + order: 5, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'By using the `.` (dot) notation (e.g., `person.name`).', + is_correct: true + }, + { + label: 'By using square brackets (e.g., `person["name"]`).', + is_correct: false + }, + { + label: 'By using the `get` method (e.g., `person.get("name")`).', + is_correct: false + }, + { + label: 'By using parentheses (e.g., `person("name")`).', + is_correct: false + } + ] + }, + { + title: 'What is an index signature in TypeScript object types?', + name: 'q6', + points: 1, + order: 6, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A type that defines the index of an array.', + is_correct: false + }, + { + label: 'A type that specifies the data type of the keys and the corresponding value data types in an object.', + is_correct: true + }, + { + label: 'A type that represents the number of properties in an object.', + is_correct: false + }, + { + label: 'A type that represents the order of properties in an object.', + is_correct: false + } + ] + }, + { + title: 'Can object types in TypeScript have methods?', + name: 'q7', + points: 1, + order: 7, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Yes, object types can have methods defined within them.', + is_correct: true + }, + { + label: 'No, object types can only have properties but not methods.', + is_correct: false + }, + { + label: 'Methods in TypeScript are defined separately from object types.', + is_correct: false + }, + { + label: 'Methods can only be defined in classes, not object types.', + is_correct: false + } + ] + }, + { + title: 'What is the key difference between an interface and a type alias for defining object types in TypeScript?', + name: 'q8', + points: 1, + order: 8, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Interfaces are more flexible and allow for dynamic typing, while type aliases are more rigid.', + is_correct: false + }, + { + label: 'Interfaces can be extended and implemented, while type aliases cannot.', + is_correct: true + }, + { + label: 'Type aliases are more powerful and can define complex types, while interfaces are limited.', + is_correct: false + }, + { + label: 'There is no difference between interfaces and type aliases for defining object types.', + is_correct: false + } + ] + }, + { + title: 'Which keyword is used to define an optional property in TypeScript object types?', + name: 'q9', + points: 1, + order: 9, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'The `optional` keyword.', + is_correct: false + }, + { + label: 'The `maybe` keyword.', + is_correct: false + }, + { + label: 'The `undefined` keyword.', + is_correct: false + }, + { + label: 'The `?` (question mark) symbol.', + is_correct: true + } + ] + }, + { + title: 'What is object destructuring in TypeScript?', + name: 'q10', + points: 1, + order: 10, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A process of destroying objects to free up memory.', + is_correct: false + }, + { + label: 'A way to create new objects from existing objects.', + is_correct: false + }, + { + label: 'A technique for extracting properties from objects and assigning them to variables.', + is_correct: true + }, + { + label: 'A method for combining multiple objects into one.', + is_correct: false + } + ] + } + ] + } +}; + +export default template; diff --git a/src/lib/mocks/typescript/006_ts_enums.ts b/src/lib/mocks/typescript/006_ts_enums.ts new file mode 100644 index 00000000..7eef8d58 --- /dev/null +++ b/src/lib/mocks/typescript/006_ts_enums.ts @@ -0,0 +1,264 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Enums Quiz', + description: 'Test your knowledge of TypeScript enums.', + questionnaire: { + questions: [ + { + title: 'What is an enum in TypeScript?', + name: 'q1', + points: 1, + order: 1, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A keyword used to declare variables in TypeScript.', + is_correct: false + }, + { + label: 'A way to define a collection of related named constant values.', + is_correct: true + }, + { + label: 'A type of function in TypeScript.', + is_correct: false + }, + { + label: 'A type of loop in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'Which keyword is used to define an enum in TypeScript?', + name: 'q2', + points: 1, + order: 2, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'enum', + is_correct: true + }, + { + label: 'class', + is_correct: false + }, + { + label: 'interface', + is_correct: false + }, + { + label: 'type', + is_correct: false + } + ] + }, + { + title: 'What is the default value of the first enum member if not explicitly assigned?', + name: 'q3', + points: 1, + order: 3, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: '0', + is_correct: true + }, + { + label: '1', + is_correct: false + }, + { + label: 'undefined', + is_correct: false + }, + { + label: 'null', + is_correct: false + } + ] + }, + { + title: 'How do you access enum members in TypeScript?', + name: 'q4', + points: 1, + order: 4, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'By using dot notation (e.g., `EnumName.MemberName`).', + is_correct: true + }, + { + label: 'By using square brackets (e.g., `EnumName["MemberName"]`).', + is_correct: false + }, + { + label: 'By using parentheses (e.g., `EnumName("MemberName")`).', + is_correct: false + }, + { + label: 'By using the `get` method (e.g., `EnumName.get("MemberName")`).', + is_correct: false + } + ] + }, + { + title: 'In TypeScript, can enums have string values as members?', + name: 'q5', + points: 1, + order: 5, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Yes, enums can only have string values as members.', + is_correct: false + }, + { + label: 'Yes, enums can have both numeric and string values as members.', + is_correct: true + }, + { + label: 'No, enums can only have numeric values as members.', + is_correct: false + }, + { + label: 'No, enums cannot have values assigned to their members.', + is_correct: false + } + ] + }, + { + title: 'What is the purpose of using enums in TypeScript?', + name: 'q6', + points: 1, + order: 6, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'To define classes in TypeScript.', + is_correct: false + }, + { + label: 'To define named constants representing a set of related values.', + is_correct: true + }, + { + label: 'To define functions in TypeScript.', + is_correct: false + }, + { + label: 'To define interfaces in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'What is the benefit of using enums over plain objects in TypeScript?', + name: 'q7', + points: 1, + order: 7, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Enums provide better performance and memory management.', + is_correct: false + }, + { + label: 'Enums are easier to use when working with a fixed set of values.', + is_correct: true + }, + { + label: 'Enums are not recommended over plain objects in TypeScript.', + is_correct: false + }, + { + label: 'Enums can be used to create instances of objects.', + is_correct: false + } + ] + }, + { + title: 'Can enum members have the same name within the same enum?', + name: 'q8', + points: 1, + order: 8, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Yes, enum members can have the same name within the same enum.', + is_correct: false + }, + { + label: 'No, enum members must have unique names within the same enum.', + is_correct: true + }, + { + label: 'Enum members are not allowed in TypeScript.', + is_correct: false + }, + { + label: 'The naming of enum members does not matter.', + is_correct: false + } + ] + }, + { + title: 'In TypeScript, can you assign a value to an enum member that is not part of the enum?', + name: 'q9', + points: 1, + order: 9, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Yes, you can assign any value to an enum member in TypeScript.', + is_correct: true + }, + { + label: 'No, enum members must have values that are part of the enum.', + is_correct: false + }, + { + label: 'Enum members do not have values in TypeScript.', + is_correct: false + }, + { + label: 'The assignment of enum values is determined by the compiler.', + is_correct: false + } + ] + }, + { + title: 'What is the benefit of using numeric values for enum members?', + name: 'q10', + points: 1, + order: 10, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Numeric values allow for better type checking and inference in TypeScript.', + is_correct: true + }, + { + label: 'Numeric values make enums harder to use and understand.', + is_correct: false + }, + { + label: 'Numeric values are not recommended for enum members.', + is_correct: false + }, + { + label: 'Numeric values are required for all enum members in TypeScript.', + is_correct: false + } + ] + } + ] + } +}; + +export default template; diff --git a/src/lib/mocks/typescript/007_ts_interfaces.ts b/src/lib/mocks/typescript/007_ts_interfaces.ts new file mode 100644 index 00000000..51f228ef --- /dev/null +++ b/src/lib/mocks/typescript/007_ts_interfaces.ts @@ -0,0 +1,264 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Aliases and Interfaces Quiz', + description: 'Test your knowledge of TypeScript aliases and interfaces.', + questionnaire: { + questions: [ + { + title: 'What is an interface in TypeScript?', + name: 'q1', + points: 1, + order: 1, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A way to create custom data types.', + is_correct: false + }, + { + label: 'A way to implement classes in TypeScript.', + is_correct: false + }, + { + label: 'A way to define the structure of an object.', + is_correct: true + }, + { + label: 'A way to declare variables in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'What is a type alias in TypeScript?', + name: 'q2', + points: 1, + order: 2, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A way to assign a type to a variable.', + is_correct: false + }, + { + label: 'A way to create an alias for a type, making it easier to refer to.', + is_correct: true + }, + { + label: 'A way to create an instance of a class.', + is_correct: false + }, + { + label: 'A way to define interfaces in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'Which keyword is used to define an interface in TypeScript?', + name: 'q3', + points: 1, + order: 3, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'interface', + is_correct: true + }, + { + label: 'class', + is_correct: false + }, + { + label: 'type', + is_correct: false + }, + { + label: 'alias', + is_correct: false + } + ] + }, + { + title: 'In TypeScript, can a class implement multiple interfaces?', + name: 'q4', + points: 1, + order: 4, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'No, a class can only implement one interface.', + is_correct: false + }, + { + label: 'Yes, a class can implement multiple interfaces.', + is_correct: true + }, + { + label: 'Interfaces cannot be implemented by classes in TypeScript.', + is_correct: false + }, + { + label: 'Classes in TypeScript do not support interfaces.', + is_correct: false + } + ] + }, + { + title: 'What is the benefit of using type aliases in TypeScript?', + name: 'q5', + points: 1, + order: 5, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Type aliases provide better performance than interfaces.', + is_correct: false + }, + { + label: 'Type aliases are used to create new classes in TypeScript.', + is_correct: false + }, + { + label: 'Type aliases make it easier to refer to complex types.', + is_correct: true + }, + { + label: 'Type aliases are used to define interfaces in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'Can you add properties to an object using an interface in TypeScript?', + name: 'q6', + points: 1, + order: 6, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'No, interfaces are only used for type checking.', + is_correct: true + }, + { + label: 'Yes, interfaces can be used to add properties to objects.', + is_correct: false + }, + { + label: 'Interfaces are not used to work with objects in TypeScript.', + is_correct: false + }, + { + label: 'Interfaces can only be used with classes in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'What is a benefit of using interfaces for function type declarations in TypeScript?', + name: 'q7', + points: 1, + order: 7, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Interfaces are not used for function type declarations in TypeScript.', + is_correct: false + }, + { + label: 'Interfaces allow you to define the expected function signature.', + is_correct: true + }, + { + label: 'Interfaces make functions easier to call in TypeScript.', + is_correct: false + }, + { + label: 'Interfaces add runtime validation to functions in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'What is the purpose of an index signature in TypeScript?', + name: 'q8', + points: 1, + order: 8, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Index signatures are not used in TypeScript.', + is_correct: false + }, + { + label: 'Index signatures define the data types of object properties.', + is_correct: false + }, + { + label: 'Index signatures allow dynamic property access on objects.', + is_correct: true + }, + { + label: 'Index signatures are used to create new types in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'Which keyword is used to define a type alias in TypeScript?', + name: 'q9', + points: 1, + order: 9, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'type', + is_correct: true + }, + { + label: 'interface', + is_correct: false + }, + { + label: 'alias', + is_correct: false + }, + { + label: 'class', + is_correct: false + } + ] + }, + { + title: 'In TypeScript, can you extend multiple type aliases?', + name: 'q10', + points: 1, + order: 10, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'No, you can only extend one type alias at a time.', + is_correct: false + }, + { + label: 'Yes, you can extend multiple type aliases in TypeScript.', + is_correct: true + }, + { + label: 'Type aliases cannot be extended in TypeScript.', + is_correct: false + }, + { + label: 'Type aliases can only be extended by classes in TypeScript.', + is_correct: false + } + ] + } + ] + } +}; + +export default template; diff --git a/src/lib/mocks/typescript/008_ts_unionTypes.ts b/src/lib/mocks/typescript/008_ts_unionTypes.ts new file mode 100644 index 00000000..1db0dd7e --- /dev/null +++ b/src/lib/mocks/typescript/008_ts_unionTypes.ts @@ -0,0 +1,264 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Union Types Quiz', + description: 'Test your knowledge of TypeScript union types.', + questionnaire: { + questions: [ + { + title: 'What are union types used for in TypeScript?', + name: 'q1', + points: 1, + order: 1, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'To define a type that can be one of several types.', + is_correct: true + }, + { + label: 'To create a new type by combining two types.', + is_correct: false + }, + { + label: 'To define a type that must be all types in the union.', + is_correct: false + }, + { + label: 'Union types are not used in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'How do you declare a union type in TypeScript?', + name: 'q2', + points: 1, + order: 2, + question_type: QuestionTypes[1], // CHECKBOX type + options: [ + { + label: 'Using the `union` keyword.', + is_correct: false + }, + { + label: 'Using the `|` symbol between type names.', + is_correct: true + }, + { + label: 'Using the `&` symbol between type names.', + is_correct: false + }, + { + label: 'Using the `type` keyword followed by parentheses.', + is_correct: false + } + ] + }, + { + title: 'What is the result of a union type that includes `null` or `undefined`?', + name: 'q3', + points: 1, + order: 3, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'The union type cannot include `null` or `undefined`.', + is_correct: false + }, + { + label: 'It allows the value to be `null`, `undefined`, or any other specified type.', + is_correct: true + }, + { + label: 'It forces the value to be both `null` and `undefined` simultaneously.', + is_correct: false + }, + { + label: 'The union type becomes a non-nullable type.', + is_correct: false + } + ] + }, + { + title: 'Which symbol is used to separate type options in a union type?', + name: 'q4', + points: 1, + order: 4, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Comma (,)', + is_correct: false + }, + { + label: 'Semicolon (;)', + is_correct: false + }, + { + label: 'Pipe (|)', + is_correct: true + }, + { + label: 'Ampersand (&)', + is_correct: false + } + ] + }, + { + title: 'What is a discriminated union in TypeScript?', + name: 'q5', + points: 1, + order: 5, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A union type with a single option.', + is_correct: false + }, + { + label: 'A union type that combines multiple types without discrimination.', + is_correct: false + }, + { + label: 'A union type where each option has a common property to discriminate between them.', + is_correct: true + }, + { + label: 'A union type that is only used for numbers.', + is_correct: false + } + ] + }, + { + title: 'What is the TypeScript keyword for a non-null assertion?', + name: 'q6', + points: 1, + order: 6, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'NotNull', + is_correct: false + }, + { + label: 'NonNull', + is_correct: false + }, + { + label: 'Undefined', + is_correct: false + }, + { + label: '!', + is_correct: true + } + ] + }, + { + title: 'In a union type, can you access properties that are not common to all types?', + name: 'q7', + points: 1, + order: 7, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Yes, TypeScript allows accessing all properties in a union type.', + is_correct: false + }, + { + label: 'No, you can only access properties common to all types in the union.', + is_correct: true + }, + { + label: 'It depends on the specific property being accessed.', + is_correct: false + }, + { + label: 'You can access properties of one type but not the others.', + is_correct: false + } + ] + }, + { + title: 'What does the `as` keyword do in TypeScript union types?', + name: 'q8', + points: 1, + order: 8, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'It creates a new union type.', + is_correct: false + }, + { + label: 'It converts a type to a different type in the union.', + is_correct: true + }, + { + label: 'It enforces strict type checking.', + is_correct: false + }, + { + label: 'It is used for optional properties.', + is_correct: false + } + ] + }, + { + title: 'What is the purpose of the `never` type in TypeScript?', + name: 'q9', + points: 1, + order: 9, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'To define a type that can never have any values.', + is_correct: true + }, + { + label: 'To define a type for numeric values only.', + is_correct: false + }, + { + label: 'To create a type that is nullable.', + is_correct: false + }, + { + label: 'To define a type that can have any value.', + is_correct: false + } + ] + }, + { + title: 'Can you use TypeScript union types with class constructors?', + name: 'q10', + points: 1, + order: 10, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'Yes, union types can be used with class constructors.', + is_correct: true + }, + { + label: 'No, union types are only for primitive types.', + is_correct: false + }, + { + label: 'Union types are used with interfaces, not classes.', + is_correct: false + }, + { + label: 'Union types cannot be used with functions or classes.', + is_correct: false + } + ] + } + ] + } +}; + +export default template; diff --git a/src/lib/mocks/typescript/009_ts_functions.ts b/src/lib/mocks/typescript/009_ts_functions.ts new file mode 100644 index 00000000..752a6325 --- /dev/null +++ b/src/lib/mocks/typescript/009_ts_functions.ts @@ -0,0 +1,247 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Functions Quiz', + description: 'Test your knowledge of TypeScript functions.', + questionnaire: { + questions: [ + { + title: 'What is a function in TypeScript?', + name: 'q1', + points: 1, + order: 1, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A function is a variable in TypeScript.', + is_correct: false + }, + { + label: 'A function is a block of code that can be executed and reused.', + is_correct: true + }, + { + label: 'A function is a type of loop in TypeScript.', + is_correct: false + }, + { + label: 'A function is a reserved keyword in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'What is the syntax for defining a function in TypeScript?', + name: 'q2', + points: 1, + order: 2, + question_type: QuestionTypes[1], // CHECKBOX type + options: [ + { + label: 'function functionName() { }', + is_correct: true + }, + { + label: 'func functionName() { }', + is_correct: false + }, + { + label: 'const functionName = () => { }', + is_correct: true + }, + { + label: 'def functionName() { }', + is_correct: false + } + ] + }, + { + title: 'What is a parameter in a function?', + name: 'q3', + points: 1, + order: 3, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A parameter is a variable declared inside a function.', + is_correct: true + }, + { + label: 'A parameter is a function that takes another function as an argument.', + is_correct: false + }, + { + label: 'A parameter is the return value of a function.', + is_correct: false + }, + { + label: 'A parameter is a built-in keyword in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'What is the purpose of the `return` statement in a function?', + name: 'q4', + points: 1, + order: 4, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'The `return` statement defines a new function.', + is_correct: false + }, + { + label: 'The `return` statement is used to exit a loop.', + is_correct: false + }, + { + label: 'The `return` statement specifies the value that the function will return.', + is_correct: true + }, + { + label: 'The `return` statement is not used in functions.', + is_correct: false + } + ] + }, + { + title: 'What is a TypeScript arrow function?', + name: 'q5', + points: 1, + order: 5, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'An arrow function is a function with a circular shape.', + is_correct: false + }, + { + label: 'An arrow function is a concise way to write function expressions in TypeScript.', + is_correct: true + }, + { + label: 'An arrow function is a type of function that uses arrows instead of parentheses.', + is_correct: false + }, + { + label: 'An arrow function is a deprecated feature in TypeScript.', + is_correct: false + } + ] + }, + { + title: 'What is the purpose of the `this` keyword in a function?', + name: 'q6', + points: 1, + order: 6, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'The `this` keyword refers to the function itself.', + is_correct: false + }, + { + label: 'The `this` keyword refers to the global object.', + is_correct: false + }, + { + label: 'The `this` keyword refers to the current instance of an object.', + is_correct: true + }, + { + label: 'The `this` keyword is not used in functions.', + is_correct: false + } + ] + }, + { + title: 'What is a TypeScript generator function?', + name: 'q7', + points: 1, + order: 7, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'A generator function is a function that generates random values.', + is_correct: false + }, + { + label: 'A generator function is a special type of function that can pause and resume its execution.', + is_correct: true + }, + { + label: 'A generator function is a function that generates HTML code.', + is_correct: false + }, + { + label: 'A generator function is not a valid TypeScript feature.', + is_correct: false + } + ] + }, + { + title: 'What is the purpose of the `yield` keyword in a generator function?', + name: 'q8', + points: 1, + order: 8, + question_type: QuestionTypes[0], // RADIO type + options: [ + { + label: 'The `yield` keyword is used to yield control back to the caller of the generator function.', + is_correct: true + }, + { + label: 'The `yield` keyword is used to terminate the generator function.', + is_correct: false + }, + { + label: 'The `yield` keyword has no specific purpose in generator functions.', + is_correct: false + }, + { + label: 'The `yield` keyword is used to specify the return value of the generator function.', + is_correct: false + } + ] + }, + { + title: 'Can a TypeScript function have multiple return statements?', + name: 'q9', + points: 1, + order: 9, + question_type: QuestionTypes[1], // CHECKBOX type + options: [ + { + label: 'Yes, a function can have multiple return statements.', + is_correct: true + }, + { + label: 'No, a function can only have one return statement.', + is_correct: false + }, + { + label: 'It depends on the type of function.', + is_correct: false + }, + { + label: 'Multiple return statements are only allowed in arrow functions.', + is_correct: false + } + ] + }, + { + title: 'What is function overloading in TypeScript?', + name: 'q10', + points: 1, + order: 10, + question_type: QuestionTypes[2], // TEXTAREA type + options: [] // No options for TEXTAREA type + } + ] + } +}; + +export default template; diff --git a/src/lib/mocks/typescript/010_ts_casting.ts b/src/lib/mocks/typescript/010_ts_casting.ts new file mode 100644 index 00000000..5f44c75c --- /dev/null +++ b/src/lib/mocks/typescript/010_ts_casting.ts @@ -0,0 +1,132 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Quiz', + description: 'Test your TypeScript knowledge!', + questionnaire: { + questions: [ + { + title: 'What is TypeScript?', + name: 'q1', + points: 2, + order: 1, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'A programming language', is_correct: false }, + { label: 'A superset of JavaScript', is_correct: true }, + { label: 'A text editor', is_correct: false }, + ], + }, + { + title: 'How do you declare a variable in TypeScript?', + name: 'q2', + points: 2, + order: 2, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'var x = 5;', is_correct: false }, + { label: 'let x = 5;', is_correct: true }, + { label: 'const x = 5;', is_correct: false }, + ], + }, + { + title: 'What is the output of 2 + "2" in TypeScript?', + name: 'q3', + points: 2, + order: 3, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: '4', is_correct: false }, + { label: '22', is_correct: true }, + { label: 'TypeError', is_correct: false }, + ], + }, + { + title: 'How do you define an array in TypeScript?', + name: 'q4', + points: 2, + order: 4, + question_type: QuestionTypes[1], // CHECKBOX + options: [ + { label: 'let arr = [1, 2, 3];', is_correct: true }, + { label: 'const arr = {1, 2, 3};', is_correct: false }, + { label: 'var arr = [1, 2, 3];', is_correct: true }, + { label: 'array arr = [1, 2, 3];', is_correct: false }, + ], + }, + { + title: 'What keyword is used to define a function in TypeScript?', + name: 'q5', + points: 2, + order: 5, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'function', is_correct: true }, + { label: 'method', is_correct: false }, + { label: 'func', is_correct: false }, + ], + }, + { + title: 'How do you typecast in TypeScript?', + name: 'q6', + points: 2, + order: 6, + question_type: QuestionTypes[2], // TEXTAREA + options: [], + }, + { + title: 'What is the purpose of TypeScript?', + name: 'q7', + points: 2, + order: 7, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'To add static typing to JavaScript', is_correct: true }, + { label: 'To replace JavaScript', is_correct: false }, + { label: 'To make JavaScript run faster', is_correct: false }, + ], + }, + { + title: 'How do you define an interface in TypeScript?', + name: 'q8', + points: 2, + order: 8, + question_type: QuestionTypes[1], // CHECKBOX + options: [ + { label: 'interface MyInterface {}', is_correct: true }, + { label: 'type MyInterface = {};', is_correct: false }, + { label: 'class MyInterface {}', is_correct: false }, + { label: 'interface = MyInterface {};', is_correct: false }, + ], + }, + { + title: 'What is the output of console.log(typeof undefined) in TypeScript?', + name: 'q9', + points: 2, + order: 9, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'undefined', is_correct: true }, + { label: 'null', is_correct: false }, + { label: 'object', is_correct: false }, + ], + }, + { + title: 'How do you define a class in TypeScript?', + name: 'q10', + points: 2, + order: 10, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'class MyClass {}', is_correct: true }, + { label: 'interface MyClass {}', is_correct: false }, + { label: 'type MyClass = {};', is_correct: false }, + ], + }, + ], + }, +}; + +export default template; diff --git a/src/lib/mocks/typescript/011_ts_classes.ts b/src/lib/mocks/typescript/011_ts_classes.ts new file mode 100644 index 00000000..c8156306 --- /dev/null +++ b/src/lib/mocks/typescript/011_ts_classes.ts @@ -0,0 +1,133 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Classes Quiz', + description: 'Test your knowledge of TypeScript classes!', + questionnaire: { + questions: [ + { + title: 'What is a class in TypeScript?', + name: 'q1', + points: 2, + order: 1, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'A data structure', is_correct: false }, + { label: 'A blueprint for creating objects', is_correct: true }, + { label: 'A function', is_correct: false }, + ], + }, + { + title: 'How do you define a class in TypeScript?', + name: 'q2', + points: 2, + order: 2, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'class MyClass {}', is_correct: true }, + { label: 'interface MyClass {}', is_correct: false }, + { label: 'type MyClass = {};', is_correct: false }, + ], + }, + { + title: 'What is the keyword used to create an instance of a class in TypeScript?', + name: 'q3', + points: 2, + order: 3, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'new', is_correct: true }, + { label: 'instance', is_correct: false }, + { label: 'create', is_correct: false }, + ], + }, + { + title: 'How do you define a constructor in a TypeScript class?', + name: 'q4', + points: 2, + order: 4, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'constructor()', is_correct: true }, + { label: 'init()', is_correct: false }, + { label: 'create()', is_correct: false }, + ], + }, + { + title: 'In TypeScript, can a class inherit from multiple classes?', + name: 'q5', + points: 2, + order: 5, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Yes', is_correct: true }, + { label: 'No', is_correct: false }, + ], + }, + { + title: 'What is the purpose of the "super" keyword in a subclass constructor?', + name: 'q6', + points: 2, + order: 6, + question_type: QuestionTypes[1], // CHECKBOX + options: [ + { label: 'To call the constructor of the superclass', is_correct: true }, + { label: 'To create a new instance of the superclass', is_correct: false }, + { label: 'To access static methods of the superclass', is_correct: false }, + ], + }, + { + title: 'How do you mark a class property as private in TypeScript?', + name: 'q7', + points: 2, + order: 7, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'private property;', is_correct: false }, + { label: 'public property;', is_correct: false }, + { label: 'private property: type;', is_correct: true }, + ], + }, + { + title: 'What is the purpose of the "protected" keyword for class members?', + name: 'q8', + points: 2, + order: 8, + question_type: QuestionTypes[1], // CHECKBOX + options: [ + { label: 'To make members accessible only within the class', is_correct: false }, + { label: 'To make members accessible within subclasses', is_correct: true }, + { label: 'To make members accessible globally', is_correct: false }, + ], + }, + { + title: 'What is the difference between an abstract class and a regular class in TypeScript?', + name: 'q9', + points: 2, + order: 9, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Abstract classes cannot have constructors', is_correct: false }, + { label: 'Abstract classes cannot be instantiated directly', is_correct: true }, + { label: 'Regular classes cannot have methods', is_correct: false }, + ], + }, + { + title: 'How do you define an abstract method in a TypeScript abstract class?', + name: 'q10', + points: 2, + order: 10, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'abstract method();', is_correct: true }, + { label: 'virtual method();', is_correct: false }, + { label: 'function method();', is_correct: false }, + ], + }, + ], + }, +}; + +export default template; diff --git a/src/lib/mocks/typescript/012_ts_basicGenerics.ts b/src/lib/mocks/typescript/012_ts_basicGenerics.ts new file mode 100644 index 00000000..264eb3b6 --- /dev/null +++ b/src/lib/mocks/typescript/012_ts_basicGenerics.ts @@ -0,0 +1,133 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Generics Quiz', + description: 'Test your knowledge of TypeScript generics!', + questionnaire: { + questions: [ + { + title: 'What are generics in TypeScript?', + name: 'q1', + points: 2, + order: 1, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'A type of fruit', is_correct: false }, + { label: 'A way to make functions and classes more reusable', is_correct: true }, + { label: 'A type of loop', is_correct: false }, + ], + }, + { + title: 'How do you declare a generic type parameter in TypeScript?', + name: 'q2', + points: 2, + order: 2, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: '', is_correct: true }, + { label: '[T]', is_correct: false }, + { label: '{T}', is_correct: false }, + ], + }, + { + title: 'What is the purpose of generics in TypeScript?', + name: 'q3', + points: 2, + order: 3, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'To specify the return type of a function', is_correct: false }, + { label: 'To create reusable functions and classes that work with different types', is_correct: true }, + { label: 'To define the structure of an object', is_correct: false }, + ], + }, + { + title: 'How do you use a generic type parameter in a function in TypeScript?', + name: 'q4', + points: 2, + order: 4, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'By enclosing it in square brackets like [T]', is_correct: false }, + { label: 'By enclosing it in angle brackets like ', is_correct: true }, + { label: 'By using curly braces like {T}', is_correct: false }, + ], + }, + { + title: 'What is the purpose of specifying a generic type constraint in TypeScript?', + name: 'q5', + points: 2, + order: 5, + question_type: QuestionTypes[1], // CHECKBOX + options: [ + { label: 'To limit the types that can be used with the generic', is_correct: true }, + { label: 'To allow any type to be used with the generic', is_correct: false }, + { label: 'To specify the default type for the generic', is_correct: false }, + ], + }, + { + title: 'How do you declare a generic class in TypeScript?', + name: 'q6', + points: 2, + order: 6, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'class MyClass {}', is_correct: true }, + { label: 'interface MyClass {}', is_correct: false }, + { label: 'type MyClass = {};', is_correct: false }, + ], + }, + { + title: 'What is the purpose of the "extends" keyword in a generic type constraint?', + name: 'q7', + points: 2, + order: 7, + question_type: QuestionTypes[1], // CHECKBOX + options: [ + { label: 'To specify a type that the generic type parameter must extend', is_correct: true }, + { label: 'To specify a type that the generic type parameter must be equal to', is_correct: false }, + { label: 'To specify a type that the generic type parameter must not extend', is_correct: false }, + ], + }, + { + title: 'Can you use generics with TypeScript arrays?', + name: 'q8', + points: 2, + order: 8, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'No, generics can only be used with classes', is_correct: false }, + { label: 'Yes, you can create generic arrays', is_correct: true }, + ], + }, + { + title: 'What is the benefit of using generics with TypeScript arrays?', + name: 'q9', + points: 2, + order: 9, + question_type: QuestionTypes[1], // CHECKBOX + options: [ + { label: 'Allows you to specify the type of elements in the array', is_correct: true }, + { label: 'Makes arrays faster', is_correct: false }, + { label: 'Prevents you from using arrays', is_correct: false }, + ], + }, + { + title: 'What is the syntax for using generics with TypeScript functions?', + name: 'q10', + points: 2, + order: 10, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'function myFunction() {}', is_correct: true }, + { label: 'function myFunction: () => {}', is_correct: false }, + { label: 'function myFunction => () {}', is_correct: false }, + ], + }, + ], + }, +}; + +export default template; diff --git a/src/lib/mocks/typescript/013_ts_utilityTypes.ts b/src/lib/mocks/typescript/013_ts_utilityTypes.ts new file mode 100644 index 00000000..3f931fa6 --- /dev/null +++ b/src/lib/mocks/typescript/013_ts_utilityTypes.ts @@ -0,0 +1,137 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Utility Types Quiz', + description: 'Test your knowledge of TypeScript utility types!', + questionnaire: { + questions: [ + { + title: 'What are TypeScript utility types?', + name: 'q1', + points: 2, + order: 1, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Built-in TypeScript types', is_correct: true }, + { label: 'JavaScript utility functions', is_correct: false }, + { label: 'Custom types defined by developers', is_correct: false }, + ], + }, + { + title: 'Which TypeScript utility type is used to create a new type that is a subset of an existing type?', + name: 'q2', + points: 2, + order: 2, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Partial', is_correct: false }, + { label: 'Pick', is_correct: false }, + { label: 'Omit', is_correct: false }, + { label: 'Subset', is_correct: true }, + ], + }, + { + title: 'What does the TypeScript utility type "Partial" do?', + name: 'q3', + points: 2, + order: 3, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Makes a type required', is_correct: false }, + { label: 'Makes a type optional', is_correct: true }, + { label: 'Creates a union type', is_correct: false }, + ], + }, + { + title: 'Which TypeScript utility type allows you to pick specific properties from an object type?', + name: 'q4', + points: 2, + order: 4, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Partial', is_correct: false }, + { label: 'Pick', is_correct: true }, + { label: 'Omit', is_correct: false }, + ], + }, + { + title: 'How do you use the TypeScript utility type "Record" to define a dictionary type?', + name: 'q5', + points: 2, + order: 5, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Record', is_correct: true }, + { label: 'Record', is_correct: false }, + { label: 'Record', is_correct: false }, + ], + }, + { + title: 'Which TypeScript utility type removes specific properties from an object type?', + name: 'q6', + points: 2, + order: 6, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Partial', is_correct: false }, + { label: 'Pick', is_correct: false }, + { label: 'Omit', is_correct: true }, + ], + }, + { + title: 'What is the purpose of the TypeScript utility type "Required"?', + name: 'q7', + points: 2, + order: 7, + question_type: QuestionTypes[1], // CHECKBOX + options: [ + { label: 'Makes all properties in a type required', is_correct: true }, + { label: 'Makes all properties in a type optional', is_correct: false }, + { label: 'Creates a new type with some required properties', is_correct: false }, + ], + }, + { + title: 'Which TypeScript utility type is used to create a new type that is the opposite of the specified type?', + name: 'q8', + points: 2, + order: 8, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Partial', is_correct: false }, + { label: 'Required', is_correct: false }, + { label: 'Exclude', is_correct: true }, + { label: 'Extract', is_correct: false }, + ], + }, + { + title: 'What is the purpose of the TypeScript utility type "Exclude"?', + name: 'q9', + points: 2, + order: 9, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Includes specific properties in a type', is_correct: false }, + { label: 'Excludes specific properties from a type', is_correct: true }, + { label: 'Creates a union type', is_correct: false }, + ], + }, + { + title: 'Which TypeScript utility type is used to create a new type that is the intersection of the specified types?', + name: 'q10', + points: 2, + order: 10, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Partial', is_correct: false }, + { label: 'Required', is_correct: false }, + { label: 'Exclude', is_correct: false }, + { label: 'Extract', is_correct: true }, + ], + }, + ], + }, +}; + +export default template; diff --git a/src/lib/mocks/typescript/014_ts_keyOf.ts b/src/lib/mocks/typescript/014_ts_keyOf.ts new file mode 100644 index 00000000..0d68c14b --- /dev/null +++ b/src/lib/mocks/typescript/014_ts_keyOf.ts @@ -0,0 +1,132 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript keyof Quiz', + description: 'Test your knowledge of TypeScript keyof!', + questionnaire: { + questions: [ + { + title: 'What does the "keyof" keyword do in TypeScript?', + name: 'q1', + points: 2, + order: 1, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Creates a new key in an object', is_correct: false }, + { label: 'Returns an array of keys from an object', is_correct: false }, + { label: 'Returns a union of keys from an object', is_correct: true }, + ], + }, + { + title: 'How do you use the "keyof" keyword to access the keys of an object type?', + name: 'q2', + points: 2, + order: 2, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'keyof object', is_correct: true }, + { label: 'object.keys', is_correct: false }, + { label: 'object.keys()', is_correct: false }, + ], + }, + { + title: 'What is the type of a variable declared using the "keyof" keyword?', + name: 'q3', + points: 2, + order: 3, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'string', is_correct: true }, + { label: 'number', is_correct: false }, + { label: 'boolean', is_correct: false }, + ], + }, + { + title: 'In TypeScript, can you use "keyof" with object instances?', + name: 'q4', + points: 2, + order: 4, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Yes, "keyof" works with both object types and instances', is_correct: false }, + { label: 'No, "keyof" only works with object types', is_correct: true }, + ], + }, + { + title: 'What is the purpose of using "keyof" with mapped types in TypeScript?', + name: 'q5', + points: 2, + order: 5, + question_type: QuestionTypes[1], // CHECKBOX + options: [ + { label: 'To create new keys in an object', is_correct: false }, + { label: 'To create a union of keys from multiple objects', is_correct: true }, + { label: 'To filter out specific keys from an object', is_correct: false }, + ], + }, + { + title: 'How do you use "keyof" with generic types in TypeScript?', + name: 'q6', + points: 2, + order: 6, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'keyof T', is_correct: true }, + { label: 'keyof', is_correct: false }, + { label: 'keyof(T)', is_correct: false }, + ], + }, + { + title: 'Which of the following is a valid use case for "keyof" in TypeScript?', + name: 'q7', + points: 2, + order: 7, + question_type: QuestionTypes[1], // CHECKBOX + options: [ + { label: 'Creating new object keys', is_correct: false }, + { label: 'Accessing the values of an object', is_correct: false }, + { label: 'Accessing object keys as string literals', is_correct: true }, + ], + }, + { + title: 'What is the return type of the "keyof" keyword in TypeScript?', + name: 'q8', + points: 2, + order: 8, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'string', is_correct: true }, + { label: 'number', is_correct: false }, + { label: 'boolean', is_correct: false }, + ], + }, + { + title: 'In TypeScript, is "keyof" limited to object types, or can it also be used with other types?', + name: 'q9', + points: 2, + order: 9, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'It can only be used with object types', is_correct: false }, + { label: 'It can be used with any type', is_correct: true }, + ], + }, + { + title: 'What is the purpose of "keyof" in TypeScript when working with type constraints?', + name: 'q10', + points: 2, + order: 10, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'To limit the type of keys that can be accessed', is_correct: false }, + { label: 'To specify which keys are required in an object', is_correct: false }, + { label: 'To ensure that a key exists in a given type', is_correct: true }, + ], + }, + ], + }, +}; + +export default template; diff --git a/src/lib/mocks/typescript/015_ts_null.ts b/src/lib/mocks/typescript/015_ts_null.ts new file mode 100644 index 00000000..089a79aa --- /dev/null +++ b/src/lib/mocks/typescript/015_ts_null.ts @@ -0,0 +1,134 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Null and Undefined Quiz', + description: 'Test your knowledge of TypeScript null and undefined!', + questionnaire: { + questions: [ + { + title: 'What is the value of a variable that has been declared but not assigned in TypeScript?', + name: 'q1', + points: 2, + order: 1, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'null', is_correct: false }, + { label: 'undefined', is_correct: true }, + { label: '0', is_correct: false }, + ], + }, + { + title: 'What is the difference between null and undefined in TypeScript?', + name: 'q2', + points: 2, + order: 2, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'There is no difference; they are the same.', is_correct: false }, + { label: 'null represents an intentional absence of any object value, while undefined represents a variable that has been declared but not assigned.', is_correct: true }, + { label: 'null is a number with a value of zero, while undefined is a number with a value of NaN.', is_correct: false }, + ], + }, + { + title: 'How can you explicitly set a variable to have a value of null in TypeScript?', + name: 'q3', + points: 2, + order: 3, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Using the "undefined" keyword', is_correct: false }, + { label: 'By assigning the value null to the variable', is_correct: true }, + { label: 'By using the "NaN" keyword', is_correct: false }, + ], + }, + { + title: 'Which of the following statements is true about the "undefined" type in TypeScript?', + name: 'q4', + points: 2, + order: 4, + question_type: QuestionTypes[1], // CHECKBOX + options: [ + { label: 'It represents the absence of a value', is_correct: true }, + { label: 'It is a subtype of all other types', is_correct: true }, + { label: 'It is the same as "null"', is_correct: false }, + { label: 'It cannot be assigned to a variable', is_correct: false }, + ], + }, + { + title: 'In TypeScript, how do you check if a variable is null or undefined?', + name: 'q5', + points: 2, + order: 5, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Using the "void" keyword', is_correct: false }, + { label: 'Using the "isNullOrUndefined" function', is_correct: false }, + { label: 'Using strict equality operators (===)', is_correct: true }, + ], + }, + { + title: 'What does the "nullish coalescing operator (??)" do in TypeScript?', + name: 'q6', + points: 2, + order: 6, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'It performs bitwise operations on null and undefined values', is_correct: false }, + { label: 'It throws an error when used with null or undefined values', is_correct: false }, + { label: 'It returns the right-hand operand if the left-hand operand is null or undefined, otherwise it returns the left-hand operand', is_correct: true }, + ], + }, + { + title: 'What is the value of a variable that has not been declared in TypeScript?', + name: 'q7', + points: 2, + order: 7, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'null', is_correct: false }, + { label: 'undefined', is_correct: false }, + { label: 'An error is thrown', is_correct: true }, + ], + }, + { + title: 'How do you assign a variable to be explicitly undefined in TypeScript?', + name: 'q8', + points: 2, + order: 8, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Using the "null" keyword', is_correct: false }, + { label: 'By not assigning any value to the variable', is_correct: false }, + { label: 'By assigning the value undefined to the variable', is_correct: true }, + ], + }, + { + title: 'What does the "void" keyword represent in TypeScript?', + name: 'q9', + points: 2, + order: 9, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'An empty value', is_correct: true }, + { label: 'A null value', is_correct: false }, + { label: 'An undefined value', is_correct: false }, + ], + }, + { + title: 'In TypeScript, can you use "undefined" as a variable name?', + name: 'q10', + points: 2, + order: 10, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Yes, "undefined" is a valid variable name', is_correct: true }, + { label: 'No, "undefined" is a reserved keyword and cannot be used as a variable name', is_correct: false }, + ], + }, + ], + }, +}; + +export default template; diff --git a/src/lib/mocks/typescript/016_ts_definitelyTyped.ts b/src/lib/mocks/typescript/016_ts_definitelyTyped.ts new file mode 100644 index 00000000..5d339c7c --- /dev/null +++ b/src/lib/mocks/typescript/016_ts_definitelyTyped.ts @@ -0,0 +1,134 @@ +import { QuestionTypes } from '../utils'; + +import type { ExerciseTemplate } from '$lib/utils/types'; + +const template: ExerciseTemplate = { + title: 'TypeScript Definitely Typed Quiz', + description: 'Test your knowledge of TypeScript Definitely Typed!', + questionnaire: { + questions: [ + { + title: 'What is TypeScript Definitely Typed?', + name: 'q1', + points: 2, + order: 1, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'A built-in TypeScript feature', is_correct: false }, + { label: 'A website that hosts TypeScript libraries with type definitions', is_correct: true }, + { label: 'A TypeScript compiler option', is_correct: false }, + ], + }, + { + title: 'What is the purpose of Definitely Typed in TypeScript?', + name: 'q2', + points: 2, + order: 2, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'To create new TypeScript language features', is_correct: false }, + { label: 'To provide type definitions for JavaScript libraries', is_correct: true }, + { label: 'To optimize TypeScript code for performance', is_correct: false }, + ], + }, + { + title: 'How do you install type definitions for a library using Definitely Typed?', + name: 'q3', + points: 2, + order: 3, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'By running "npm install @types/library-name"', is_correct: true }, + { label: 'By manually copying and pasting type definitions into your project', is_correct: false }, + { label: 'By using the "tsc" command with a special flag', is_correct: false }, + ], + }, + { + title: 'Which TypeScript compiler option is used to automatically download type definitions for a library?', + name: 'q4', + points: 2, + order: 4, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: '--download-types', is_correct: false }, + { label: '--include-types', is_correct: false }, + { label: '--types', is_correct: true }, + ], + }, + { + title: 'What is the file extension for Definitely Typed type definition files?', + name: 'q5', + points: 2, + order: 5, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: '.d.ts', is_correct: true }, + { label: '.ts', is_correct: false }, + { label: '.def', is_correct: false }, + ], + }, + { + title: 'In a Definitely Typed type definition file, what does the "declare" keyword indicate?', + name: 'q6', + points: 2, + order: 6, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'That the type definition is private and cannot be accessed', is_correct: false }, + { label: 'That the type definition is for external code and not part of the current project', is_correct: true }, + { label: 'That the type definition is for internal code and should not be used externally', is_correct: false }, + ], + }, + { + title: 'What is the primary benefit of using Definitely Typed in TypeScript projects?', + name: 'q7', + points: 2, + order: 7, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'It reduces the size of the compiled JavaScript files', is_correct: false }, + { label: 'It ensures that all code is written in TypeScript', is_correct: false }, + { label: 'It provides type safety and auto-completion for JavaScript libraries', is_correct: true }, + ], + }, + { + title: 'Which command is used to search for type definitions on Definitely Typed?', + name: 'q8', + points: 2, + order: 8, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'npm search @types', is_correct: false }, + { label: 'npm install @types', is_correct: false }, + { label: 'npx search-definitely-typed', is_correct: true }, + ], + }, + { + title: 'What should you do if there is no available Definitely Typed type definition for a library?', + name: 'q9', + points: 2, + order: 9, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Manually create your own type definition file', is_correct: true }, + { label: 'Abandon the use of the library in your project', is_correct: false }, + { label: 'Use the "any" type to bypass type checking', is_correct: false }, + ], + }, + { + title: 'How can you contribute to Definitely Typed by providing type definitions for a library?', + name: 'q10', + points: 2, + order: 10, + question_type: QuestionTypes[0], // RADIO + options: [ + { label: 'Submit a pull request to the Definitely Typed repository with your type definitions', is_correct: true }, + { label: 'Send an email to the Definitely Typed maintainers', is_correct: false }, + { label: 'Post the type definitions on a personal blog', is_correct: false }, + ], + }, + ], + }, +}; + +export default template; diff --git a/src/lib/mocks/typescript/index.ts b/src/lib/mocks/typescript/index.ts new file mode 100644 index 00000000..0273ccc9 --- /dev/null +++ b/src/lib/mocks/typescript/index.ts @@ -0,0 +1,55 @@ +import tsSimpleTypes from './001_ts_simpleTypes'; +import tsSpecialTypes from './002_ts_specialTypes'; +import tsArrays from './003_ts_arrays'; +import tsTuples from './004_ts_tuples'; +import tsObjectTypes from './005_ts_objectTypes'; +import tsEnums from './006_ts_enums'; +import tsInterfaces from './007_ts_interfaces'; +import tsUnionTypes from './008_ts_unionTypes'; +import tsFunctions from './009_ts_functions'; +import tsCasting from './010_ts_casting'; +import tsClasses from './011_ts_classes'; +import tsBasicGenerics from './012_ts_basicGenerics'; +import tsUtilityTypes from './013_ts_utilityTypes'; +import tsKeyOf from './014_ts_keyOf'; +import tsNull from './015_ts_null'; +import tsDefinitelyTyped from './016_ts_definitelyTyped'; + + +export const TS_IDS: { [key: string]: string } = { + TS_SIMPLETYPES: 'TS_SIMPLETYPES', + TS_SPECIALTYPES: 'TS_SPECIALTYPES', + TS_ARRAYS: 'TS_ARRAYS', + TS_TUPLES: 'TS_TUPLES', + TS_OBJECTTYPES: 'TS_OBJECTTYPES', + TS_ENUMS: 'TS_ENUMS', + TS_INTERFACES: 'TS_INTERFACES', + TS_UNIONTYPES: 'TS_UNIONTYPES', + TS_FUNCTIONS: 'TS_FUNCTIONS', + TS_CASTING: 'TS_CASTING', + TS_CLASSES: 'TS_CLASSES', + TS_BASICGENERICS: 'TS_BASICGENERICS', + TS_UTILITYTYPES: 'TS_UTILITYTYPES', + TS_KEYOF: 'TS_KEYOF', + TS_NULL: 'TS_NULL', + TS_DEFINITELYTYPED: 'TS_DEFINITELYTYPED', +}; + +export const TS_TEMPLATES = { + [TS_IDS.TS_SIMPLETYPES]: tsSimpleTypes, + [TS_IDS.TS_SPECIALTYPES]: tsSpecialTypes, + [TS_IDS.TS_ARRAYS]: tsArrays, + [TS_IDS.TS_TUPLES]: tsTuples, + [TS_IDS.TS_OBJECTTYPES]: tsObjectTypes, + [TS_IDS.TS_ENUMS]: tsEnums, + [TS_IDS.TS_INTERFACES]: tsInterfaces, + [TS_IDS.TS_UNIONTYPES]: tsUnionTypes, + [TS_IDS.TS_FUNCTIONS]: tsFunctions, + [TS_IDS.TS_CASTING]: tsCasting, + [TS_IDS.TS_CLASSES]: tsClasses, + [TS_IDS.TS_BASICGENERICS]: tsBasicGenerics, + [TS_IDS.TS_UTILITYTYPES]: tsUtilityTypes, + [TS_IDS.TS_KEYOF]: tsKeyOf, + [TS_IDS.TS_NULL]: tsNull, + [TS_IDS.TS_DEFINITELYTYPED]: tsDefinitelyTyped, +};