no se puede volver a declarar la variable de ámbito de bloque (mecanografiado)

Estoy construyendo una aplicación de nodo, y dentro de cada archivo en .js solía hacer esto para requerir en varios paquetes.

let co = require("co");

Pero conseguir

etc. Entonces, usando mecanografiado, parece que solo puede haber una declaración / requerimiento de este tipo en todo el proyecto. Estoy confundido acerca de esto, ya que pensé que letestaba en el ámbito del archivo actual.

Acabo de tener un proyecto que estaba funcionando, pero después de una refactorización ahora recibo estos errores por todas partes.

¿Alguien puede explicarlo?

Con respecto al error en sí, letse utiliza para declarar variables locales que existen en ámbitos de bloque en lugar de ámbitos de función. También es más estricto que var, por lo que no puedes hacer cosas como esta:

if (condition) {
    let a = 1;
    ...
    let a = 2;
}

También tenga en cuenta que las casecláusulas dentro de los switchbloques no crean sus propios ámbitos de bloque, por lo que no puede volver a declarar la misma variable local en varios cases sin usar {}para crear un bloque cada una.

En cuanto a la importación, es probable que reciba este error porque TypeScript no reconoce sus archivos como módulos reales, y aparentemente las definiciones a nivel de modelo terminan siendo definiciones globales para él.

Intente importar un módulo externo de la forma estándar ES6 , que no contiene una asignación explícita, y debería hacer que TypeScript reconozca sus archivos correctamente como módulos:

import * as co from "./co"

Esto aún resultará en un error de compilación si ya tiene algo nombrado co, como se esperaba. Por ejemplo, esto será un error:

import * as co from "./co"; // Error: import definition conflicts with local definition
let co = 1;

Si recibe un error "no se puede encontrar el módulo co" ...

TypeScript está ejecutando una verificación de tipos completa contra los módulos, por lo que si no tiene definiciones de TS para el módulo que está intentando importar (por ejemplo, porque es un módulo JS sin archivos de definición), puede declarar su módulo en un .d.tsarchivo de definición que no no contienen exportaciones a nivel de módulo:

declare module "co" {
    declare var co: any;
    export = co;
}

La mejor explicación que pude obtener es la publicación de Tamas Piro .

TLDR; TypeScript utiliza las tipificaciones DOM para el entorno de ejecución global. En su caso, hay una propiedad 'co' en el objeto de ventana global.

Para solucionar esto:

1. Cambiar el nombre de la variable, o
2. Use módulos de TypeScript y agregue una exportación vacía {}:

export {};

o

3. Configure las opciones de su compilador sin agregar tipos de DOM:

Edite tsconfig.json en el directorio del proyecto de TypeScript.

{
    "compilerOptions": {
        "lib": ["es6"]
      }
}

Recibí este error similar al compilar mi aplicación Typecript Node.JS:

node_modules/@types/node/index.d.ts:83:15 - error TS2451: Cannot redeclare block-scoped variable 'custom'.

La solución fue eliminar esto:

"files": [
  "./node_modules/@types/node/index.d.ts"
]

y reemplazarlo con esto:

"compilerOptions": {
  "types": ["node"]
}

Uso IIFE(Immediately Invoked Function Expression), IIFE

(function () {
    all your code is here...

 })();

Para aquellos que vienen aquí en esta era, aquí hay una solución simple a este problema. Al menos funcionó para mí en el backend. No he comprobado con el código de la interfaz.

Solo agrega:

export {};

en la parte superior de su código.

Crédito a EUGENE MURAVITSKY

Tengo el mismo problema y mi solución se ve así:

// *./module1/module1.ts*
export module Module1 {
    export class Module1{
        greating(){ return 'hey from Module1'}
    }
}


// *./module2/module2.ts*
import {Module1} from './../module1/module1';

export module Module2{
    export class Module2{
        greating(){
            let m1 = new Module1.Module1()
            return 'hey from Module2 + and from loaded Model1: '+ m1.greating();
        }
    }
}

Ahora podemos usarlo en el lado del servidor:

// *./server.ts*
/// <reference path="./typings/node/node.d.ts"/>
import {Module2} from './module2/module2';

export module Server {
    export class Server{
        greating(){
            let m2 = new Module2.Module2();
            return "hello from server & loaded modules: " + m2.greating();
        }
    }
}

exports.Server = Server;

// ./app.js
var Server = require('./server').Server.Server;
var server = new Server();
console.log(server.greating());

Y del lado del cliente también:

// *./public/javscripts/index/index.ts*

import {Module2} from './../../../module2/module2';

document.body.onload = function(){
    let m2 = new Module2.Module2();
    alert(m2.greating());
}

// ./views/index.jade
extends layout

block content
  h1= title
  p Welcome to #{title}
  script(src='main.js')
  //
    the main.js-file created by gulp-task 'browserify' below in the gulpfile.js

Y, por supuesto, un archivo gulp para todo esto:

// *./gulpfile.js*
var gulp = require('gulp'),
    ts = require('gulp-typescript'),
    runSequence = require('run-sequence'),
    browserify = require('gulp-browserify'),
    rename = require('gulp-rename');

gulp.task('default', function(callback) {

    gulp.task('ts1', function() {
        return gulp.src(['./module1/module1.ts'])
            .pipe(ts())
            .pipe(gulp.dest('./module1'))
    });

    gulp.task('ts2', function() {
        return gulp.src(['./module2/module2.ts'])
            .pipe(ts())
            .pipe(gulp.dest('./module2'))
    });

    gulp.task('ts3', function() {
        return gulp.src(['./public/javascripts/index/index.ts'])
            .pipe(ts())
            .pipe(gulp.dest('./public/javascripts/index'))
    });

    gulp.task('browserify', function() {
        return gulp.src('./public/javascripts/index/index.js', { read: false })
            .pipe(browserify({
                insertGlobals: true
            }))
            .pipe(rename('main.js'))
            .pipe(gulp.dest('./public/javascripts/'))
    });

    runSequence('ts1', 'ts2', 'ts3', 'browserify', callback);
})

Actualizado. Por supuesto, no es necesario compilar archivos mecanografiados por separado. runSequence(['ts1', 'ts2', 'ts3'], 'browserify', callback)funciona perfecto.

Recibí este error al actualizar

gulp-mecanografiado 3.0.2 → 3.1.0

Poniéndolo de nuevo a 3.0.2 lo solucionó

En mi caso, el siguiente tsconfig.jsonproblema resuelto:

{
  "compilerOptions": {
    "esModuleInterop": true,
    "target": "ES2020",
    "moduleResolution": "node"
  }
}

No debería haber type: modulein package.json.