@enjoys/context-engine 1.0.0 → 1.0.1

package/data/completion/typescript.json

@@ -0,0 +1,338 @@
+{
+  "language": "typescript",
+  "completions": [
+    {
+      "label": "interface",
+      "kind": 14,
+      "detail": "Interface declaration",
+      "documentation": { "value": "Defines the shape of an object.\n\n```typescript\ninterface User {\n  id: number;\n  name: string;\n  email?: string;\n}\n```" },
+      "insertText": "interface ${1:Name} {\n\t${2:prop}: ${3:type};\n}",
+      "insertTextRules": 4,
+      "sortText": "00_interface"
+    },
+    {
+      "label": "type",
+      "kind": 14,
+      "detail": "Type alias declaration",
+      "documentation": { "value": "Creates a type alias for complex types.\n\n```typescript\ntype StringOrNumber = string | number;\ntype User = { id: number; name: string };\ntype Result<T> = { data: T } | { error: string };\n```" },
+      "insertText": "type ${1:Name} = ${2:type};",
+      "insertTextRules": 4,
+      "sortText": "00_type"
+    },
+    {
+      "label": "enum",
+      "kind": 13,
+      "detail": "Enum declaration",
+      "documentation": { "value": "Defines a set of named constants.\n\n```typescript\nenum Direction {\n  Up = 'UP',\n  Down = 'DOWN',\n  Left = 'LEFT',\n  Right = 'RIGHT'\n}\n```" },
+      "insertText": "enum ${1:Name} {\n\t${2:Member} = '${3:value}',\n}",
+      "insertTextRules": 4,
+      "sortText": "00_enum"
+    },
+    {
+      "label": "Record",
+      "kind": 7,
+      "detail": "Record<Keys, Type>",
+      "documentation": { "value": "Constructs an object type whose property keys are `Keys` and values are `Type`.\n\n```typescript\ntype PageInfo = Record<string, { title: string; url: string }>;\nconst pages: Record<'home' | 'about', number> = { home: 1, about: 2 };\n```" },
+      "insertText": "Record<${1:string}, ${2:any}>",
+      "insertTextRules": 4,
+      "sortText": "01_Record"
+    },
+    {
+      "label": "Partial",
+      "kind": 7,
+      "detail": "Partial<Type>",
+      "documentation": { "value": "Constructs a type with all properties of `Type` set to optional.\n\n```typescript\ninterface Todo { title: string; description: string; }\nfunction updateTodo(todo: Todo, fields: Partial<Todo>) { ... }\n```" },
+      "insertText": "Partial<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "01_Partial"
+    },
+    {
+      "label": "Required",
+      "kind": 7,
+      "detail": "Required<Type>",
+      "documentation": { "value": "Constructs a type with all properties of `Type` set to required.\n\n```typescript\ninterface Props { a?: number; b?: string; }\nconst obj: Required<Props> = { a: 5, b: 'hello' };\n```" },
+      "insertText": "Required<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "01_Required"
+    },
+    {
+      "label": "Readonly",
+      "kind": 7,
+      "detail": "Readonly<Type>",
+      "documentation": { "value": "Constructs a type with all properties set to `readonly`.\n\n```typescript\nconst config: Readonly<Config> = { port: 3000 };\nconfig.port = 8080; // Error!\n```" },
+      "insertText": "Readonly<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "01_Readonly"
+    },
+    {
+      "label": "Pick",
+      "kind": 7,
+      "detail": "Pick<Type, Keys>",
+      "documentation": { "value": "Constructs a type by picking the set of properties `Keys` from `Type`.\n\n```typescript\ntype TodoPreview = Pick<Todo, 'title' | 'completed'>;\n```" },
+      "insertText": "Pick<${1:Type}, ${2:Keys}>",
+      "insertTextRules": 4,
+      "sortText": "01_Pick"
+    },
+    {
+      "label": "Omit",
+      "kind": 7,
+      "detail": "Omit<Type, Keys>",
+      "documentation": { "value": "Constructs a type by removing the set of properties `Keys` from `Type`.\n\n```typescript\ntype TodoInfo = Omit<Todo, 'completed' | 'createdAt'>;\n```" },
+      "insertText": "Omit<${1:Type}, ${2:Keys}>",
+      "insertTextRules": 4,
+      "sortText": "01_Omit"
+    },
+    {
+      "label": "Exclude",
+      "kind": 7,
+      "detail": "Exclude<UnionType, Excluded>",
+      "documentation": { "value": "Constructs a type by excluding from `UnionType` all members that are assignable to `Excluded`.\n\n```typescript\ntype T = Exclude<'a' | 'b' | 'c', 'a'>; // 'b' | 'c'\n```" },
+      "insertText": "Exclude<${1:UnionType}, ${2:Excluded}>",
+      "insertTextRules": 4,
+      "sortText": "01_Exclude"
+    },
+    {
+      "label": "Extract",
+      "kind": 7,
+      "detail": "Extract<Type, Union>",
+      "documentation": { "value": "Constructs a type by extracting from `Type` all union members assignable to `Union`.\n\n```typescript\ntype T = Extract<'a' | 'b' | 'c', 'a' | 'f'>; // 'a'\n```" },
+      "insertText": "Extract<${1:Type}, ${2:Union}>",
+      "insertTextRules": 4,
+      "sortText": "01_Extract"
+    },
+    {
+      "label": "NonNullable",
+      "kind": 7,
+      "detail": "NonNullable<Type>",
+      "documentation": { "value": "Constructs a type by excluding `null` and `undefined` from `Type`.\n\n```typescript\ntype T = NonNullable<string | null | undefined>; // string\n```" },
+      "insertText": "NonNullable<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "01_NonNullable"
+    },
+    {
+      "label": "ReturnType",
+      "kind": 7,
+      "detail": "ReturnType<Type>",
+      "documentation": { "value": "Constructs a type from the return type of a function type.\n\n```typescript\nfunction getUser() { return { id: 1, name: 'Alice' }; }\ntype User = ReturnType<typeof getUser>; // { id: number; name: string }\n```" },
+      "insertText": "ReturnType<typeof ${1:fn}>",
+      "insertTextRules": 4,
+      "sortText": "01_ReturnType"
+    },
+    {
+      "label": "Parameters",
+      "kind": 7,
+      "detail": "Parameters<Type>",
+      "documentation": { "value": "Constructs a tuple type from the types of the parameters of a function type.\n\n```typescript\ntype T = Parameters<(a: string, b: number) => void>; // [string, number]\n```" },
+      "insertText": "Parameters<typeof ${1:fn}>",
+      "insertTextRules": 4,
+      "sortText": "01_Parameters"
+    },
+    {
+      "label": "Awaited",
+      "kind": 7,
+      "detail": "Awaited<Type>",
+      "documentation": { "value": "Recursively unwraps the `Awaited` type of a `Promise`.\n\n```typescript\ntype A = Awaited<Promise<string>>; // string\ntype B = Awaited<Promise<Promise<number>>>; // number\n```" },
+      "insertText": "Awaited<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "01_Awaited"
+    },
+    {
+      "label": "keyof",
+      "kind": 14,
+      "detail": "keyof operator",
+      "documentation": { "value": "Produces a union of the property names (keys) of a type.\n\n```typescript\ninterface User { id: number; name: string; }\ntype UserKeys = keyof User; // 'id' | 'name'\n```" },
+      "insertText": "keyof ${1:Type}",
+      "insertTextRules": 4,
+      "sortText": "00_keyof"
+    },
+    {
+      "label": "typeof",
+      "kind": 14,
+      "detail": "typeof type operator",
+      "documentation": { "value": "Obtains the type of a variable or property in a type context.\n\n```typescript\nconst config = { port: 3000, host: 'localhost' };\ntype Config = typeof config; // { port: number; host: string }\n```" },
+      "insertText": "typeof ${1:variable}",
+      "insertTextRules": 4,
+      "sortText": "00_typeof"
+    },
+    {
+      "label": "as const",
+      "kind": 14,
+      "detail": "Const assertion",
+      "documentation": { "value": "Asserts that an expression should be inferred as its most specific (literal) type.\n\n```typescript\nconst colors = ['red', 'green', 'blue'] as const;\n// readonly ['red', 'green', 'blue']\n```" },
+      "insertText": "as const",
+      "insertTextRules": 1,
+      "sortText": "00_as_const"
+    },
+    {
+      "label": "satisfies",
+      "kind": 14,
+      "detail": "satisfies operator (TS 4.9+)",
+      "documentation": { "value": "Validates that a value matches a type without widening the inferred type.\n\n```typescript\ntype Colors = Record<string, [number, number, number] | string>;\nconst palette = {\n  red: [255, 0, 0],\n  green: '#00ff00',\n} satisfies Colors;\n```" },
+      "insertText": "satisfies ${1:Type}",
+      "insertTextRules": 4,
+      "sortText": "00_satisfies"
+    },
+    {
+      "label": { "label": "generic function", "detail": " declaration", "description": "TypeScript" },
+      "kind": 15,
+      "detail": "Generic function snippet",
+      "documentation": { "value": "Declares a generic function with type parameter.\n\n```typescript\nfunction identity<T>(arg: T): T {\n  return arg;\n}\n```" },
+      "insertText": "function ${1:name}<${2:T}>(${3:arg}: ${2:T}): ${4:ReturnType} {\n\t${5}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_generic_function"
+    },
+    {
+      "label": { "label": "type guard", "detail": " function", "description": "TypeScript" },
+      "kind": 15,
+      "detail": "Type guard function",
+      "documentation": { "value": "A function that narrows a type via a type predicate.\n\n```typescript\nfunction isString(value: unknown): value is string {\n  return typeof value === 'string';\n}\n```" },
+      "insertText": "function ${1:isType}(${2:value}: unknown): ${2:value} is ${3:Type} {\n\treturn ${4:condition};\n}",
+      "insertTextRules": 4,
+      "sortText": "00_type_guard"
+    },
+    {
+      "label": { "label": "mapped type", "detail": " declaration", "description": "TypeScript" },
+      "kind": 15,
+      "detail": "Mapped type",
+      "documentation": { "value": "Creates a new type by transforming each property of an existing type.\n\n```typescript\ntype Optional<T> = {\n  [K in keyof T]?: T[K];\n};\n```" },
+      "insertText": "type ${1:Name}<T> = {\n\t[K in keyof T]${2:: T[K]};\n};",
+      "insertTextRules": 4,
+      "sortText": "00_mapped_type"
+    },
+    {
+      "label": { "label": "conditional type", "detail": " expression", "description": "TypeScript" },
+      "kind": 15,
+      "detail": "Conditional type",
+      "documentation": { "value": "Selects one of two types based on a condition.\n\n```typescript\ntype IsString<T> = T extends string ? true : false;\ntype A = IsString<'hello'>; // true\ntype B = IsString<42>;      // false\n```" },
+      "insertText": "type ${1:Name}<T> = T extends ${2:Condition} ? ${3:TrueType} : ${4:FalseType};",
+      "insertTextRules": 4,
+      "sortText": "00_conditional_type"
+    },
+    {
+      "label": { "label": "infer", "detail": " in conditional type", "description": "TypeScript" },
+      "kind": 15,
+      "detail": "Infer keyword in conditional type",
+      "documentation": { "value": "Infers a type within a conditional type.\n\n```typescript\ntype UnpackPromise<T> = T extends Promise<infer U> ? U : T;\ntype A = UnpackPromise<Promise<string>>; // string\n```" },
+      "insertText": "T extends ${1:Type}<infer ${2:U}> ? ${2:U} : ${3:never}",
+      "insertTextRules": 4,
+      "sortText": "00_infer"
+    },
+    {
+      "label": { "label": "template literal type", "detail": "", "description": "TS 4.1+" },
+      "kind": 15,
+      "detail": "Template literal type",
+      "documentation": { "value": "Build string types using template literal syntax.\n\n```typescript\ntype EventName = `on${Capitalize<string>}`;\ntype Color = 'red' | 'blue';\ntype Size = 'sm' | 'lg';\ntype Token = `${Color}-${Size}`; // 'red-sm' | 'red-lg' | 'blue-sm' | 'blue-lg'\n```" },
+      "insertText": "`${${1:Prefix}}${${2:Type}}`",
+      "insertTextRules": 4,
+      "sortText": "00_template_literal_type"
+    },
+    {
+      "label": "Uppercase",
+      "kind": 7,
+      "detail": "Uppercase<StringType>",
+      "documentation": { "value": "Converts each character in the string to uppercase.\n\n```typescript\ntype T = Uppercase<'hello'>; // 'HELLO'\n```" },
+      "insertText": "Uppercase<${1:StringType}>",
+      "insertTextRules": 4,
+      "sortText": "01_Uppercase"
+    },
+    {
+      "label": "Lowercase",
+      "kind": 7,
+      "detail": "Lowercase<StringType>",
+      "documentation": { "value": "Converts each character in the string to lowercase.\n\n```typescript\ntype T = Lowercase<'HELLO'>; // 'hello'\n```" },
+      "insertText": "Lowercase<${1:StringType}>",
+      "insertTextRules": 4,
+      "sortText": "01_Lowercase"
+    },
+    {
+      "label": "Capitalize",
+      "kind": 7,
+      "detail": "Capitalize<StringType>",
+      "documentation": { "value": "Converts the first character in the string to uppercase.\n\n```typescript\ntype T = Capitalize<'hello'>; // 'Hello'\n```" },
+      "insertText": "Capitalize<${1:StringType}>",
+      "insertTextRules": 4,
+      "sortText": "01_Capitalize"
+    },
+    {
+      "label": "ConstructorParameters",
+      "kind": 7,
+      "detail": "ConstructorParameters<Type>",
+      "documentation": { "value": "Extracts parameter types from a constructor function type.\n\n```typescript\ntype T = ConstructorParameters<typeof Date>;\n```" },
+      "insertText": "ConstructorParameters<typeof ${1:Class}>",
+      "insertTextRules": 4,
+      "sortText": "01_ConstructorParameters"
+    },
+    {
+      "label": "InstanceType",
+      "kind": 7,
+      "detail": "InstanceType<Type>",
+      "documentation": { "value": "Constructs a type consisting of the instance type of a constructor function.\n\n```typescript\ntype D = InstanceType<typeof Date>; // Date\n```" },
+      "insertText": "InstanceType<typeof ${1:Class}>",
+      "insertTextRules": 4,
+      "sortText": "01_InstanceType"
+    },
+    {
+      "label": "NoInfer",
+      "kind": 7,
+      "detail": "NoInfer<Type> (TS 5.4+)",
+      "documentation": { "value": "Prevents TypeScript from inferring a type parameter from this position.\n\n```typescript\nfunction createFSM<S extends string>(init: S, transitions: Record<S, NoInfer<S>[]>) { }\n```" },
+      "insertText": "NoInfer<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "01_NoInfer"
+    },
+    {
+      "label": { "label": "readonly array", "detail": "", "description": "TypeScript" },
+      "kind": 15,
+      "detail": "Readonly array type",
+      "documentation": { "value": "Immutable array that cannot be modified.\n\n```typescript\nconst items: readonly string[] = ['a', 'b'];\nconst items2: ReadonlyArray<string> = ['a', 'b'];\n```" },
+      "insertText": "readonly ${1:Type}[]",
+      "insertTextRules": 4,
+      "sortText": "01_readonly_array"
+    },
+    {
+      "label": { "label": "assertion function", "detail": "", "description": "TS 3.7+" },
+      "kind": 15,
+      "detail": "Assertion function",
+      "documentation": { "value": "Function that asserts a condition and narrows the type.\n\n```typescript\nfunction assertDefined<T>(val: T): asserts val is NonNullable<T> {\n  if (val === undefined || val === null) {\n    throw new Error('Value is not defined');\n  }\n}\n```" },
+      "insertText": "function ${1:assert}(${2:value}: unknown): asserts ${2:value} is ${3:Type} {\n\tif (!${4:condition}) {\n\t\tthrow new Error('${5:Assertion failed}');\n\t}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_assertion_function"
+    },
+    {
+      "label": { "label": "namespace", "detail": " declaration", "description": "TypeScript" },
+      "kind": 15,
+      "detail": "Namespace declaration",
+      "documentation": { "value": "Organizes code in a logical grouping.\n\n```typescript\nnamespace Validation {\n  export function isValid(s: string): boolean { ... }\n}\n```" },
+      "insertText": "namespace ${1:Name} {\n\texport ${2}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_namespace"
+    },
+    {
+      "label": { "label": "abstract class", "detail": "", "description": "TypeScript" },
+      "kind": 15,
+      "detail": "Abstract class declaration",
+      "documentation": { "value": "Base class that cannot be instantiated directly.\n\n```typescript\nabstract class Shape {\n  abstract area(): number;\n  toString(): string { return `Area: ${this.area()}`; }\n}\n```" },
+      "insertText": "abstract class ${1:Name} {\n\tabstract ${2:method}(${3}): ${4:void};\n}",
+      "insertTextRules": 4,
+      "sortText": "00_abstract_class"
+    },
+    {
+      "label": { "label": "decorator", "detail": " (TS 5.0+)", "description": "Stage 3 Decorators" },
+      "kind": 15,
+      "detail": "Decorator function",
+      "documentation": { "value": "A special declaration that can be attached to class declarations, methods, accessors, properties, or parameters.\n\n```typescript\nfunction log(target: any, context: ClassMethodDecoratorContext) {\n  return function (...args: any[]) {\n    console.log(`Calling ${String(context.name)}`);\n    return target.apply(this, args);\n  };\n}\n```" },
+      "insertText": "function ${1:decorator}(target: any, context: ${2:ClassMethodDecoratorContext}) {\n\t${3}\n}",
+      "insertTextRules": 4,
+      "sortText": "00_decorator"
+    },
+    {
+      "label": { "label": "using declaration", "detail": " (TS 5.2+)", "description": "Explicit Resource Management" },
+      "kind": 15,
+      "detail": "using declaration for resource management",
+      "documentation": { "value": "Declares a resource that is automatically disposed when it goes out of scope.\n\n```typescript\nclass FileHandle implements Disposable {\n  [Symbol.dispose]() { this.close(); }\n}\n{\n  using handle = new FileHandle();\n  // handle disposed automatically\n}\n```" },
+      "insertText": "using ${1:resource} = ${2:expression};",
+      "insertTextRules": 4,
+      "sortText": "00_using"
+    }
+  ]
+}