dwjohnston's questions

Se eu tiver algum código como:

type Bravo = {
  b?: string; 
}

type Charlie = {
  c:Bravo['b']
}

function acceptsCharlie(value: Charlie){
  //'value.c' is possibly 'undefined'.(18048)
  value.c.split('');
}

Isso faz sentido - o tipo Charlieherda a string opcional de Bravo.

Podemos resolver isso usando o Requiredtipo de utilitário:

type Bravo = {
  b?: string; 
}

type Charlie = {
  //  👇
  c:Required<Bravo>['b']
}

function acceptsCharlie(value: Charlie){
  // no error here 
  value.c.split('');
}

Fácil.

Entretanto, se eu adicionar mais uma camada de pesquisa de digitação:

type Alpha = {
  a?: string; 
}

type Bravo = {
  b: Alpha['a']; 
}

type Charlie = {
  c: Required<Bravo>['b']
}

function acceptsCharlie(value: Charlie){
  //'value.c' is possibly 'undefined'.(18048)
  value.c.split('');
}

Isso Requirednão resolve mais o problema para mim.

O que acontece?

Se você tiver algum código como este:

//other.js|ts

console.log("module sideffect") 
export function foo() {

}


//main.js|ts 
import {foo} from "./other"; // foo is not used  

console.log("do something else"); 

Então JavaScript e TypeScript se comportam de forma diferente neste cenário.

O TypesScript omitirá a importação de "./other", e o console.log("module sideeffect")não será disparado.

Enquanto o JavaScript fará a importação e ela será acionada.

Se por outro lado fizermos a importação assim:

import "./other"; 

Os efeitos colaterais do módulo serão disparados.

Há uma pergunta relacionada aqui:

Efeitos colaterais nas declarações de importação

e aqui:

módulo de importação para efeitos colaterais com Typescript apenas visando o nó

Ambas falam sobre isso, mas infelizmente ambas as respostas agora apontam para a documentação do TypeScript que não existe mais.

Estou procurando uma razão canônica para o TypeScript fazer essa omissão e se é um comportamento configurável. (Pode-se imaginar um cenário em que o código para de funcionar porque uma importação não é mais usada).

Estou procurando a documentação do MDN para a função cookieStore.get .

CookieStore ainda não foi tipado pelo TypeScript , então preciso criar minha própria definição.

A pergunta que tenho é que na documentação do MDN MDN denota parâmetros opcionais para funções - mas no tipo de retorno ainda não vi valores opcionais no tipo de retorno. Isso significa que posso assumir que todos os valores listados em cookieStore.getshould/will existem?

Estou tentando criar um hook no estilo promisify. A ideia é usá-lo com o Redux Toolkit para permitir o uso do novo usehook do React 19.

Aqui está a essência de como isso funcionaria:

function usePromise(input: {
    isLoading: true,
    data: null
} | {
    isLoading: false,
    data: string;
}) {


    // Store the resolve function in a ref 
    const resRef = useRef<(data: string) => void>(null);

    // Create a new promise 
    // Store the resolve function in the ref 
    const promiseRef = useRef(
        new Promise((res) => {
            resRef.current = res;

            //res("xxx") // 👈 this will resolve though
        })
    );

    // When input changes, if there is data, resolve the promise
    useEffect(() => {
        if (!input.isLoading) {
            resRef.current?.(input.data);
        }

    }, [input]);

    // Return the promise 
    return promiseRef.current;
}

Com uso como:

export function MyComponent() {

    const [value, setValue] = useState<null | string>(null);

    const prom = usePromise(value ? {
        isLoading: false,
        data: value
    } : {
        isLoading: true,
        data: null
    });

    prom.then((v) => alert(v))

    return <div >

        <button onClick={() => setValue("123")}>Click me</button>
    </div>
}

Aqui, eu esperaria que, quando clicarmos no botão, a promessa fosse resolvida e víssemos o alerta. No entanto, isso não acontece.

O que está acontecendo aqui?

Tenho uma reprodução para esta edição aqui: https://github.com/dwjohnston/react-promise-issue

Tenho um código parecido com este:

type UserTypes = "user" | "super-user" | "admin"  ;


function getUserType() : UserTypes {

}

function getAdminPrivs(userType: "user" | "super-user") : null  
function getAdminPrivs(userType: "admin") :  string 
// nb. we need to double declare the final line
// see: https://stackoverflow.com/questions/70146081/why-does-an-overloaded-function-declaration-sometimes-force-useless-type-narrowi
function getAdminPrivs(userType: UserTypes) : null | string
function getAdminPrivs(userType: UserTypes) : null | string {

  if(userType === "admin"){
    return "hello"
  }

  return null; 
}


// "user" | "super-user" | "admin"
const userType = getUserType();

// string| null  
const result = getAdminPrivs(userType);


if(userType === "user" || userType === "super-user"){

}
else {
  // string | null 
  // I really want this to be just string
  result
}

Aqui, o que eu quero que o TypeScript faça é restringir o tipo de result, como resultado da verificação do tipo de userType. Isso é possível?

Por exemplo, se eu mudar um pouco meu código:

const userType = getUserType();
if(userType === "user" || userType === "super-user"){
  // null
  const result = getAdminPrivs(userType);
}
else {
  //string 
  const result = getAdminPrivs(userType);
}

Isso é meio que semanticamente o mesmo, mas temos a vantagem do estreitamento de tipo. (Não posso usar essa técnica no meu caso de uso real, porque getAdminPrivsna verdade é um hook do React e você não tem permissão para chamar hooks do React condicionalmente)

Estou tentando conseguir algo assim:

const input = {a: 1, b: "hello"}; 
const result = renameProperties(input,{a: "alpha", b: "beta"}); 
result.alpha // number
result.beta // string
result.foo //Property 'foo' does not exist on type... 

Então minha função de conversão está assim:

export function renameProperties<
  TInput extends Record<string, unknown>,
  TConversionMap extends Record<keyof TInput, string>,
  TOutput extends // heres where I get stuck 
>(input: TInput, conversionMap: TConversionMap): TOutput {

}

Como primeiro passo, tenho:

TOutput extends {[K in TConversionMap[keyof TInput]] : string}

Isso não se comporta exatamente como eu quero - eu esperava que o resultado contivesse apenas chaves convertidas.

result.alpha // string
result.beta // string

result.foo //string  - but really was hoping to see an error here 

A segunda parte envolveria reter o valor da entrada, eu estava pensando em algo como:

TOutput extends {[K in TConversionMap[keyof TInput]] : TInput[The Input key, if we can retain a reference to it]}

Como eu faria isso? Isso é possível?