Encontrei um arquivo chamado "degit" no código-fonte do Remotion.
Remotion ajuda você a fazer vídeos programaticamente.

Neste artigo, veremos os seguintes conceitos:

1. O que é Débito?
2. Crie uma função degit simples inspirada no arquivo degit do Remotion

O que é Débito?

Lembro-me de ter visto "degit" mencionado em um dos Leiames do código aberto, mas não conseguia lembrar qual repositório era, então pesquisei no Google o que significa um degit e encontrei este pacote degit npm.

Em termos simples, você pode usar degit para fazer rapidamente uma cópia de um repositório Github baixando apenas o commit mais recente
em vez de todo o histórico do git.

Visite o pacote npm oficial para degit para ler mais sobre este pacote.

Você também pode usar este pacote degit para baixar repositórios do Gitlab ou Bitbucket, para que não se limite apenas aos repositórios do Github.

# download from GitLab
degit gitlab:user/repo

# download from BitBucket
degit bitbucket:user/repo

degit user/repo
# these commands are equivalent
degit github:user/repo

Aqui está um exemplo de uso em Javascript:

const degit = require('degit');

const emitter = degit('user/repo', {
    cache: true,
    force: true,
    verbose: true,
});

emitter.on('info', info => {
    console.log(info.message);
});

emitter.clone('path/to/dest').then(() => {
    console.log('done');
});

Crie uma função degit simples inspirada no arquivo degit do Remotion

Para entender como construir uma função degit simples, vamos analisar o código do arquivo degit.ts do Remotion. Este arquivo implementa uma versão básica do que o pacote degit npm faz: buscar o estado mais recente de um repositório GitHub sem baixar o histórico completo.

1. Importações utilizadas

import https from 'https';
import fs from 'node:fs';
import {tmpdir} from 'node:os';
import path from 'node:path';
import tar from 'tar';
import {mkdirp} from './mkdirp';

• https: usado para fazer uma solicitação de rede para buscar o repositório.
• fs: Interage com o sistema de arquivos, como gravar os arquivos baixados.
• tmpdir: Fornece o caminho do diretório temporário do sistema.
• path: Manipula e transforma caminhos de arquivos.
• tar: Extrai o conteúdo do tarball (arquivo compactado).
• mkdirp: Uma função auxiliar para criar diretórios recursivamente, fornecida em um arquivo separado.

2: Buscando o Repositório

export function fetch(url: string, dest: string) {
    return new Promise((resolve, reject) => {
        https.get(url, (response) => {
            const code = response.statusCode as number;
            if (code >= 400) {
                reject(
                    new Error(
                        `Network request to ${url} failed with code ${code} (${response.statusMessage})`,
                    ),
                );
            } else if (code >= 300) {
                fetch(response.headers.location as string, dest)
                    .then(resolve)
                    .catch(reject);
            } else {
                response
                    .pipe(fs.createWriteStream(dest))
                    .on('finish', () => resolve())
                    .on('error', reject);
            }
        }).on('error', reject);
    });
}

• Tratamento de URL: A função verifica se a solicitação foi bem-sucedida (códigos de status abaixo de 300). Se for um redirecionamento (códigos entre 300 e 399), segue a nova URL. Se for um erro (códigos 400), rejeita a promessa.
• Salvar arquivo: o repositório é baixado e salvo no caminho de destino usando fs.createWriteStream.

3: Extraindo o Repositório

Após baixar o repositório, é necessário extrair o conteúdo do tarball:

function untar(file: string, dest: string) {
    return tar.extract(
        {
            file,
            strip: 1,
            C: dest,
        },
        [],
    );
}

• Tar Extraction: Esta função extrai o conteúdo do arquivo .tar.gz para o diretório de destino especificado.

4: Juntando tudo

A principal função degit une tudo, lidando com a criação de diretório, busca e extração do repositório:

export const degit = async ({
    repoOrg,
    repoName,
    dest,
}: {
    repoOrg: string;
    repoName: string;
    dest: string;
}) => {
    const base = path.join(tmpdir(), '.degit');
    const dir = path.join(base, repoOrg, repoName);
    const file = `${dir}/HEAD.tar.gz`;
    const url = `https://github.com/${repoOrg}/${repoName}/archive/HEAD.tar.gz`;

    mkdirp(path.dirname(file));
    await fetch(url, file);

    mkdirp(dest);
    await untar(file, dest);
    fs.unlinkSync(file);
};

mkdirp é usado para criar
um diretório recursivamente.

Conclusão:

Descobri que o remotion usa degit para baixar modelos quando você executa o comando de instalação:

npx create-video@latest

Este comando pede que você escolha um modelo, é aqui que o degit entra em ação para fazer o download
o último commit do modelo selecionado

Você pode verificar este código no pacote create-video como prova.

Receba cursos gratuitos inspirados nas melhores práticas usadas em código aberto.

Sobre mim:

Site: https://ramunarasinga.com/

Linkedin: https://www.linkedin.com/in/ramu-narasinga-189361128/

Github: https://github.com/Ramu-Narasinga

E-mail: [email protected]

Aprenda as práticas recomendadas usadas em código aberto.

Referências:

1. https://github.com/Rich-Harris/degit
2. https://github.com/remotion-dev/remotion/blob/main/packages/create-video/src/degit.ts
3. https://github.com/remotion-dev/remotion/blob/c535e676badd055187d1ea8007f9ac76ab0ad315/packages/create-video/src/init.ts#L109
4. https://github.com/remotion-dev/remotion/blob/main/packages/create-video/src/mkdirp.ts