Rollup-plugin-typescript2: Por que as declarações de interface são removidas?

Este é um erro de tempo de execução ou erro de digitação? Você poderia postar como exportar a interface do próprio RenderedCell ?

O fato é que o arquivo não é gerado e falha ao usar a biblioteca em outro projeto.

Espere, você está esperando que a interface RenderedCell seja gerada? A partir do código que você postou, seria de esperar que o arquivo denominado RenderedCell.ts existisse em um diretório acima do arquivo atual e precisaria conter algo assim:

export interface RenderedCell 
{ 
    // ...
}

Você poderia dar mais detalhes sobre a estrutura do seu projeto? (árvore de arquivos, tsconfig, configuração de rollup, etc)

sim, estou esperando que seja gerado.

Aqui estão minhas configurações:

executando a construção: rollup -c -f es -n sq-web-component-table -o dist/sq-web-component-table.es.min.js

Não coloquei a árvore inteira porque é uma biblioteca bem grande e faz mais barulho do que sinal. Mas você já pode ver que muitos arquivos não são gerados no dist.

import typescript from 'rollup-plugin-typescript2';
import uglify from 'rollup-plugin-uglify';
import { minify } from 'uglify-es';

export default {
    entry: './src/index.ts',
    dest: 'dist/sq-web-component-table.min.js',
    sourceMap: true,

    plugins: [
        typescript(),
        uglify({}, minify)
    ]
}

{
  "compilerOptions": {
    "target": "es5",
    "module": "es2015",
    "moduleResolution": "node",
    "declaration": true,
    "noImplicitAny": true,
    "noImplicitReturns": true,
    "outDir": "dist"
  },
  "include": [
    "src/**/*.ts"
  ],
  "exclude": [
    "dist",
    "node_modules",
    "**/*-test.ts"
  ]
}

import {RenderedElement} from "./RenderedElement";
import {RenderedRow} from "./RenderedRow";
export interface RenderedCell extends RenderedElement {
    isMergedCell(): boolean;
    getColspan(): number;
    setColspan(colspan: number): void;
    getParent(): RenderedRow;
}

.
├── src
│   ├── index.ts
│   └── table
│       ├── extensions
│       │   ├── base
│       │   │   ├── FirstTableExtension.ts
│       │   │   ├── LastTableExtension.ts
│       │   │   ├── SectionDispatcher.ts
│       │   │   ├── SectionManager.ts
│       │   │   └── SizeChangeMonitor.ts
│       │   ├── InvalidateEvent.ts
│       │   ├── InvalidateSizesEvent.ts
│       │   ├── RenderedCell.ts
│       │   ├── RenderedElement.ts
│       │   ├── RenderedRow.ts
│       │   ├── RenderedSection.ts
│       │   ├── RenderedTable.ts
│       │   ├── SectionClickedEvent.ts
│       │   ├── support
│       │   │   └── ...
│       │   ├── TableAttributes.ts
│       │   ├── TableExtensionChain.ts
│       │   ├── TableExtensionList.ts
│       │   └── TableExtension.ts
│       ├── model
│       │   └── ...
│       ├── TableRenderingOptions.ts
│       ├── Table.ts
│       ├── util
│       │   └── ...
│       └── view
│           └── ...
├── dist
│   ├── index.d.ts
│   ├── sq-web-component-table.es.min.js
│   ├── sq-web-component-table.es.min.js.map
│   ├── sq-web-component-table.min.js
│   ├── sq-web-component-table.min.js.map
│   └── table
│       ├── extensions
│       │   ├── base
│       │   │   ├── FirstTableExtension.d.ts
│       │   │   ├── LastTableExtension.d.ts
│       │   │   ├── SectionDispatcher.d.ts
│       │   │   ├── SectionManager.d.ts
│       │   │   └── SizeChangeMonitor.d.ts
│       │   ├── InvalidateEvent.d.ts
│       │   ├── InvalidateSizesEvent.d.ts
│       │   ├── RenderedRow.d.ts
│       │   ├── SectionClickedEvent.d.ts
│       │   ├── support
│       │   │   └── ...
│       │   ├── TableAttributes.d.ts
│       │   └── TableExtensionList.d.ts
│       ├── model
│       │   └── ...
│       ├── Table.d.ts
│       ├── util
│       │   └── ...
│       └── view
│           └── ...
├── node_modules
│   └── ...
├── __tests__
│   └── ...
├── package.json
├── rollup.config.js
└── tsconfig.json

Ah, entendo. O código aberto da lib por acaso?

Tente construir com estas opções:

typescript({ verbosity: 2, clean: true }),

Verifique se todos os arquivos que você espera estão sendo processados. Se as declarações começarem a ser geradas repentinamente, há um problema de cache em algum lugar.

Se RenderedCell.ts não for mencionado na saída ( rpt2: transpiling '...' ), aumente a verbosidade para 3 e verifique se os arquivos que deveriam ser importados estão fazendo isso. Você deveria ver algo como

rpt2: resolving '../RenderedCell'
rpt2:     to '...'

Se o problema não for óbvio, adicionarei mais registros em algum lugar.

Eu adoraria, talvez seja no futuro :)

Obrigado pelos truques, vou tentar isso na segunda-feira.

Se você definir declaration: false na seção compilerOptions de seu tsconfig e recompilar, o problema desaparece? Em caso afirmativo, o erro relatado pelo TSC está relacionado a um dos arquivos no diretório dist? Se sim for sua resposta para ambas, o erro desaparece se você introduzir alguma lógica de não tipo no arquivo que contém RenderedCell , como uma exportação de uma função simples? Se sim, o motivo é que o arquivo que contém RenderedCell é considerado não utilizado e o Typescript nunca preparará declarações para ele.

Se tudo isso se aplica a você, vejo 2 opções:

• Pare de gerar declarações para seu pacote.
• Certifique-se de que o roll-up não sacudirá completamente o arquivo, introduzindo alterações no arquivo que não estão relacionadas ao tipo. Sim, é um hack e espero que encontremos uma maneira de fazer melhor

Oi,

desculpe pela demora, tentei suas dicas e truques, mas ainda não consegui obter as definições de tipo para interfaces geradas.

Mudei a configuração para typescript({ verbosity: 3, clean: true }) .
Na saída da construção gerada, não há uma única menção à interface RenderedCell .

Tenho 100% de certeza que este arquivo é necessário, já que index.d.ts da biblioteca o requer diretamente e todos os arquivos, exceto as interfaces, são gerados, mas as interfaces ainda estão nas importações de index.d.ts Arquivo.

Vou mergulhar no código para ver se há um motivo específico pelo qual esses arquivos não são gerados.

@wessberg Parar de gerar declarações para o meu pacote não é uma opção, pois esta é uma biblioteca que faz parte de um projeto maior todo escrito em TypeScript, então se não tiver tipificações não funciona.

Então, fiz algumas investigações e criei um repositório que reproduz meu caso com um conjunto mínimo de configurações: https://github.com/onigoetz/typescript-rollup-experiment

Também incluí uma configuração do webpack para comparar como o webpack o faz funcionar.

Meu entendimento do problema é que quando rollup-plugin-typescript2 requer a versão compilada de um arquivo (digamos index.ts), o Typescript retornará os arquivos compilados e suas importações, mas sem as interfaces nas importações.

É por isso que o rollup nunca os gera: ele não tem conhecimento de sua existência.

Para executar o repositório, faça um npm install && npm run build dentro do diretório.

Se você adicionar:
import "./SomeInterface"; (exatamente assim, - sem quaisquer vínculos nomeados) para seu arquivo index.ts , ele deve funcionar. É mesmo?

Infelizmente, Rollup não invoca o manipulador de transformação de plug-ins para arquivos apenas de declaração, como arquivos contendo apenas declarações de tipo. A coisa acima deve funcionar, já que força o Rollup a avaliar o arquivo. Este problema: https://github.com/rollup/rollup-plugin-typescript/issues/28 explica como e por que esse problema existe. Teoricamente, poderíamos resolver manualmente todas as dependências de seu aplicativo a partir do ponto de entrada e determinar aquelas que contêm apenas declarações de tipo, mas não há como forçar o rollup a invocar o gancho de transformação (além de outras desvantagens óbvias, como a complexidade adicional da etapa de construção )

Infelizmente, não podemos fazer muito sobre isso sem alterar o próprio rollup. O "hack" que descrevi deve funcionar por enquanto.

Sim, acabei de verificar, adicionar import "./SomeInterface"; no repositório de teste corrige as coisas.

Ao importar apenas tipos, o typescript elimina as instruções de importação da saída js e o rollup não vê esses arquivos e, portanto, não os envia para transpilação.

Vou tentar trapacear e monitorar quais arquivos datilografados solicitados do disco versus quais arquivos rollup enviados para transpilação. Deve ser possível forçar a transpilar a diferença com apenas sinalização de definições. Em alguns casos, isso pode resultar em muitos arquivos d.ts (para coisas que o rollup foi legitimamente sacudido da árvore, por exemplo)

Obrigado por investigar, também verificarei se posso fazer uma contribuição para isso.

@onigoetz , ok, experimente seu projeto com o master. Verifique se as declarações corretas são geradas, mas também verifique se nenhuma declaração inesperada foi gerada :)

Incrível, você literalmente consertou enquanto eu estava dormindo :)

Eu testei e quase funciona bem.

Há apenas um pequeno problema, mas acho que é algo contra o qual nada podemos fazer, o webpack loader faz exatamente o mesmo e a lista de arquivos é gerada pelo próprio TypeScript.

Como um exemplo; Se eu tiver três arquivos em meu repo:

• index.ts importando SomeInterface.ts
• SomeInterface.ts
• nongenerated.ts importando SomeInterface.ts

nongenerated.ts nunca é referenciado, mas seus tipos são gerados de qualquer maneira.

Legal, obrigado pelo teste. Vou lançá-lo um pouco mais tarde, depois que outro problema for confirmado.

Sim, não podemos fazer muito ao ignorar o rollup. Você deve ser capaz de excluir esses arquivos manualmente na opção exclude , mas essa é uma solução pobre.

Ok, em 0.5.1 agora

funciona bem, basta configurar tsconfig.json

{
    "compilerOptions": {
        "module": "es2015",
        "target": "es5",
        "declaration":true,
        "declarationDir": "lib",
        "typeRoots": [
            "node_modules/@six006",
            "node_modules/@types"
        ],
        "lib": [
            "es2015",
            "es2017",
            "es5"
        ],
    },
    "include": [
        "src/index.ts",
        "src/module/**/*.ts"
    ],
    "exclude": [
        "node_modules"
    ]
}

include seção

YMMV mas consegui funcionar assim ...

antes de

export type MyType = { ... };

depois de

type MyType = { ... };

export { MyType }

Para constar, acabei de chamar tsc --emitDeclarationOnly após o rollup, que substitui os arquivos de declaração na pasta de construção.
no meu package.json

"scripts": {
    "build": "rollup -c",
    "postbuild: "tsc --emitDeclarationOnly"
}