TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
private ensureMember(): this.member is MyType {} but that doesn't work
If ESM is enabled with typescript 4.7 (by setting "type": "module" in package.json and "module": "Node16", "moduleResolution": "node16" in tsconfig.json), is it possible to import a 3rd-party module that
- has an .mjs implementation and .d.ts declaration file
- but doesn't have a .d.mts file
?
I bumped into an issue with js-base64 which fits this criteria and import attempts error with
Could not find a declaration file for module 'js-base64'. '/myproj/node_modules/js-base64/base64.mjs' implicitly has an 'any' type
But if I symlink or copy .d.ts file to .d.mts file then all is good
1 reply
Hello everyone, I need help with this:
Use the rollDice function to roll the dice 10 times. Push the result of each function call into an array, and then print the results in the console.
I'm using the import module, the function I'm importing is:
function flipCoin(min:number, max:number) {
let flipVal = random.int((min = 0), (max = 1))
any idea how I can do this? Please!! Thanks
const tosses = [...Array(10).keys()] // create an array of 10 items
.map(() => flipCoin(min, max)); // fill with tosses
console.log(tosses); // [rand1, rand2, ... rand10]
index.d.ts per entry (directory)? https://stackoverflow.com/questions/72515614/separate-index-d-ts-per-cypress-entry-instead-of-one-huge-index-d-ts
Hi guys, is it possible to make conditional type for tuple with type inference?
Very simplified example: (I can provide more detailed one too)
type TypedTuple<T extends AllAssignableTypes> = [
T,
GetArgForType<T>,
string
];
// Here it requires to specify type parameter and cannot infer it from 'A' string inside
const test: TypedTuple<'A'> = [
'A',
{ a: '', something: 1 },
'test'
];// Here I shouldn't use any, but I need array members to be of various TypedTuple types
const tuplesArray: Array<TypedTuple<any>> = [
[ '', { a: '', something: 20 }, '' ]
];type AllAssignableTypes = "B" | 5 | boolean | null;
type GetArgForType<T extends AllAssignableTypes> = { a: T, something: number };
type TypedTuple<T extends AllAssignableTypes> = [
T,
GetArgForType<T>,
string
];
const test: TypedTuple<"B"> = [
"B",
{ a: "B", something: 1 },
'test'
];
const tuplesArray: Array<TypedTuple<5|"B">> = [
[ 5, { a: 5, something: 20 }, "test" ],
[ "B", { a: "B", something: 20 }, "test" ]
];
<Blah>this to get what I want)
this: this extends Blah
import { Result } from "url-metadata";
import { Mongo } from "../lib/db";
export async function UpsertMetadata(_c: Mongo) {
const collection = _c.Collections.get("metadatas");
if (!collection) return;
const result = await collection.updateOne();
return result;
}
export async function FindAllMetadata(_c: Mongo) {
const collection = _c.Collections.get("metadatas");
if (!collection) return;
const list = await collection.find().toArray();
return list;
}
Hi everyone, I was watching https://www.youtube.com/watch?v=nNse0r0aRT8 and trying to replicate few things like IndexOf,
getting the following error The type 'readonly [1, 2, 3, 4, 5]' is 'readonly' and cannot be assigned to the mutable type '[]'.
CSB: https://codesandbox.io/s/affectionate-darkness-6q09do?file=/src/index.ts
P.S.: Those es-disabled are probably not useful here as I can't see ESlint in package
1 reply
Hello,
I wonder what is the proper way to define a string that could grow without any limit with https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-1.html#template-literal-types ?
type D1 = 0|1;
type D2 = D1|2;
type D3 = D2|3;
type D5 = D3|4|5;
type D9 = D5|6|7|8|9;
type D9_bis = 1|2|3|4|5|6|7|8|9;
type D12 = D9|10|11|12;
// Bad because of the circular reference
// Explanation in https://github.com/microsoft/TypeScript/pull/40580 is unclear IMO
type HoursDeep = `${D9}${D9}` | `${D9_bis}${HoursDeep}`;
// Currently only cover "00" to "9999"
// type Hours = `${D9}${D9}` | `${D9_bis}${D9}${D9}${D9 | ''}`;
// Needed for define something like that
type Minutes = `${D5}${D9}`;
type Seconds = `${D5}${D9}`;
type Duration = `${HoursDeep }:${Minutes}:${Seconds}`;Thanks in advance
Can someone tell me why I can call the function in the example with an immutable? How can I fix this issue?
type DeepImmutableObject<T> = {
readonly [K in keyof T]: Immutable<T[K]>
};
type Immutable<T> =
Readonly<DeepImmutableObject<T>>;
interface MyType {
isImmutable: boolean;
}
function makeTypescriptUseless(screw: MyType) {
screw.isImmutable = false;
};
const superSafeObject: Immutable<MyType> = { isImmutable: true };
makeTypescriptUseless(superSafeObject);