Werken met Zekeringenkast en Reageren

0
5

Als u op zoek bent naar een alternatief bundler te webpack, je zou willen om een kijkje te nemen bij de Zekeringenkast. Het bouwt voort op wat webpack biedt — code-splitsing, hot-module te laden dynamische invoer, enz. — maar code-splitsing in de Zekeringenkast vereist zero configuration-standaard (hoewel webpack bieden dezelfde als die van de versie 4.0).

In plaats daarvan, Zekeringenkast is gebouwd voor de eenvoud (in de vorm van minder ingewikkelde configuratie) en de prestaties (waaronder de agressieve caching methode). Plus, het kan worden uitgebreid tot een ton van de plugins die kan omgaan met alles wat je nodig hebt dan de standaard.

Oh ja, en als je een fan bent van de Schrijfmachine, bent u misschien geïnteresseerd in de wetenschap dat Zekeringenkast maakt het een eerste-rangs burger. Dat betekent dat u kunt schrijven van een toepassing op Manuscript — met geen configuratie! — en het gebruik van de Schrijfmachine transpiler te compileren scripts standaard. Niet van plan bent over het gebruik van de Schrijfmachine? Geen zorgen, de transpiler met JavaScript. Nog een andere bonus!

Om te illustreren hoe snel het is om aan de slag te gaan, laten we bouwen aan de botten van een applicatie maken-reageren-app. Alles wat we doen wordt op GitHub als u wilt volgen langs.

Zekeringenkast is niet het enige alternatief voor de webpack, natuurlijk. Er zijn tal en, in feite, Maks Akymenko heeft een grote schrijf-up op een Perceel dat is een ander goed alternatief is de moeite waard op zoek naar.

De basic setup

Begin met het aanmaken van een nieuw project directory en initialiseren met npm:

## Creëer een map
mkdir csstricks-zekeringenkast-reageer && $_
## Initialiseren met npm standaard opties
npm init -y

Nu kunnen we de installatie van een aantal afhankelijkheden. We gaan om de app te maken op Reageren, zodat we je nodig hebben, evenals reageren-dom.

npm install –opslaan reageren reageren-dom

We gaan installeren Zekeringenkast en de Schrijfmachine als afhankelijkheden. We gooien Uglify daar zo goed voor het helpen minifying onze scripts en voeg ondersteuning voor het schrijven van stijlen in Sass.

npm install –opslaan-dev zekering-box typoscript uglify-js node-sass

Oke, nu maken we een src map in de root van de project map (die kan handmatig worden gedaan). Voeg de volgende bestanden (`app.js en index.js) daar, met inbegrip van de inhoud:

// App.js

importeren van * zo Reageren van “reageren”;
importeren van * als logo van “./logo.svg”;

const App = () => {
return (
<div className=”App”>
<header className=”App-header”>
<img src={logo} className=”App-logo” alt=”logo” />
<h1 className=”App-title”>van harte Welkom om te Reageren</h1>
</header>
<p className=”App-intro”>
Aan de slag, bewerken `src/App.js` en opslaan om te herladen.
</p>
</div>
)
};

export standaard applicatie;

Je hebt misschien gemerkt dat we zijn het importeren van een SVG-bestand. U kunt direct downloaden van GitHub repo.

// index.js

importeren van * zo Reageren van “reageren”;
importeren van * als ReactDOM van de “reageer-dom”;
importeren-App uit “./App”

ReactDOM.render(
<App / > document.getElementById(‘root’)
);

U kunt zien dat de manier waarop wij omgaan met het importeren van bestanden is een beetje anders dan een typische Reageren app. Dat komt omdat Zekeringenkast niet polyfill de invoer van de standaard.

Dus, in plaats van dit te doen:

importeren Reageren van “reageren”;

…wij dit te doen:

importeren van * zo Reageren van “reageren”;
<!– ./src/index.html –>

<!DOCTYPE html>
<html lang=”nl”>
<head>
<title>CSSTricks Zekeringenkast Reageren</title>
$css
</head>

<body>
<noscript>
Je moet JavaScript inschakelen om deze app.
</noscript>
<div id=”root”></div>
$bundels
</body>
</html>

Styling is niet echt het punt van deze post, maar laten we wat in te kleden dingen een beetje. We hebben twee stylesheets. De eerste is voor de App component en opgeslagen als App.css.

/* App.css */

.App {
text-align: center;
}

.App-logo {
animatie: App-logo-spin oneindige 20s lineair;
hoogte: 80px;
}

.App-header {
background-color: #222;
hoogte: 150px;
padding: 20px;
kleur: wit;
}

.App-intro {
font-size: large;
}

@keyframes App-logo-spin {
van {
transform: rotate(0deg);
}
naar {
transformeren:
draaien(360deg);
}
}

De tweede stylesheet is voor index.js en moet opgeslagen worden als index.css:

/* index.css */
body {
margin: 0;
padding: 0;
font-family: sans-serif;
}

OK, we zijn klaar met de eerste schoonmaak. Op de uitbreiding van Zekeringenkast met wat lekkers!

Plugins en configuratie

We zeiden eerder dat het configureren van Zekeringenkast is ontworpen om te worden veel minder complex dan de wil van webpack — en dat is waar! Maak een bestand genaamd fuse.js in de hoofdmap van de toepassing.

We beginnen met het importeren van de plugins die we maken gebruik van de plug-ins komen uit de Zekeringenkast pakket geïnstalleerd is.

const { Zekeringenkast, CSSPlugin, SVGPlugin, WebIndexPlugin } = require(“fuse-box”);

We gaan initialiseren van een Zekeringenkast aanleg en vertellen wat we met behulp van de home directory en waar samengesteld activa:

const zekering = Zekeringenkast.init({
homeDir: “src”,
uitvoer: “dist/$name.js”
});

We laten FuzeBox weten dat we van plan om de Schrijfmachine compiler:

const zekering = Zekeringenkast.init({
homeDir: “src”,
uitvoer: “dist/$name.js”,
useTypescriptCompiler: true,
});

We geïdentificeerd plugins in de eerste regel van het configuratie bestand, maar nu hebben we ze ook noemen. We maken gebruik van de plug-ins vrij veel het is zoals het is, maar zeker check out wat de CSSPlugin, SVGPlugin en WebIndexPlugin te bieden als u wilt meer controle over de opties.

const zekering = Zekeringenkast.init({
homeDir: “src”,
uitvoer: “dist/$name.js”,
useTypescriptCompiler: true,
plugins: [ // MARKEREN
CSSPlugin(),
SVGPlugin(),
WebIndexPlugin({
sjabloon: “src/index.html”
})
]
});

const { Zekeringenkast, CSSPlugin, SVGPlugin, WebIndexPlugin } = require(“fuse-box”);

const zekering = Zekeringenkast.init({
homeDir: “src”,
uitvoer: “dist/$name.js”,
useTypescriptCompiler: true,
plugins: [
CSSPlugin(),
SVGPlugin(),
WebIndexPlugin({
sjabloon: “src/index.html”
})
]
});
zekering.dev();
zekering
.bundel(“app”)
.instructies(`>index.js`)
.hmr()
.watch()

zekering.run();

Zekeringenkast laat ons het configureren van een ontwikkeling server. We kunnen definiëren poorten, SSL-certificaten, en zelfs het openen van de toepassing in een browser op te bouwen.

Zullen We gewoon gebruik maken van de standaard omgeving voor dit voorbeeld:

zekering.dev();

Het is belangrijk om te definiëren van de omgeving voor de ontwikkeling van *voor* de bundel instructies die volgende:

zekering
.bundel(“app”)
.instructies(`>index.js`)
.hmr()
.watch().

Wat de heck is dit? Wanneer we geïnitialiseerd de Zekeringenkast we bijvoorbeeld opgegeven, een uitgang met dist/$name.js. De waarde voor $naam is verstrekt door de bundel() methode. In ons geval is, zetten we de waarde als app. Dat betekent dat wanneer de toepassing wordt geleverd, is de output bestemming dist/app.js.

De instructies () – methode bepaalt u hoe Zekeringenkast moet omgaan met de code. In ons geval, we vertellen het aan beginnen met index.js en om het uit te voeren nadat het is geladen.

De hmr () – methode wordt gebruikt voor zaken waar we willen voor het bijwerken van de gebruiker wanneer een bestand is gewijzigd, gaat het meestal om het updaten van de browser wanneer u een bestand wijzigt. Ondertussen kijken() re-bundels gebundeld code na elke opgeslagen wijzigen.

Met dat we de dop er af door de lancering van het build-proces met zekering.run() op het einde van het configuratie bestand. Hier is alles wat we net onder elkaar gezet:

const { Zekeringenkast, CSSPlugin, SVGPlugin, WebIndexPlugin } = require(“fuse-box”);

const zekering = Zekeringenkast.init({
homeDir: “src”,
uitvoer: “dist/$name.js”,
useTypescriptCompiler: true,
plugins: [
CSSPlugin(),
SVGPlugin(),
WebIndexPlugin({
sjabloon: “src/index.html”
})
]
});
zekering.dev();
zekering
.bundel(“app”)
.instructies(`>index.js`)
.hmr()
.watch()

zekering.run();

Nu kunnen we het programma uitvoeren vanaf de terminal door het uitvoeren van knooppunt zekering. Dit start het proces van het bouwen van die zorgt voor de dist-map waarin de programma-code en de sjabloon die we opgegeven in de configuratie. Na het proces van het bouwen wordt gedaan, kunnen we verwijzen de browser http://localhost:4444/ bekijk onze app.

Taken uitvoeren met Sparky

Zekeringenkast is voorzien van een taak loper die kan worden gebruikt voor het automatiseren van een proces op te bouwen. Het heet Sparky en je kan het zien als ongeveer zoals Grunt en de Gulp, het verschil is dat het is gebouwd op de top van de Zekeringenkast met ingebouwde toegang tot Zekeringenkast plugins en de Zekeringenkast API.

We hoeven niet te gebruiken, maar de taak lopers ontwikkeling een stuk makkelijker door het automatiseren van dingen die we zouden anders hebben om handmatig te doen en is het zinvol om te gebruiken wat speciaal is ontworpen voor de Zekeringenkast.

Om het te gebruiken, zullen we het bijwerken van de configuratie die we hebben in fuse.js, te beginnen met de invoer die op de top van het bestand:

const { src, taak, context } = require(“fuse-box/sparky”);

We gaan het definiëren van een context, die zal lijken op wat we al hebben. We zijn in feite wikkelen wat hebben we gedaan in een context en bb(), dan is het initialiseren van de Zekeringenkast in de terugkeer:

context({
bb() {
terug Zekeringenkast.init({
homeDir: “src”,
uitvoer: “dist/$name.js”,
useTypescriptCompiler: true,
plugins: [
CSSPlugin(),
SVGPlugin(),
WebIndexPlugin({
sjabloon: “src/index.html”
})
]
});
},
createBundle(zekering) {
terug zekering
.bundel(“app”)
.instructies(`> index.js`)
.hmr();
}
});

Het is mogelijk om een klasse, functie of platte object aan een context. In het bovenstaande scenario, we passeren functies, specifiek bb() en createBundle(). bb() initialiseert Zekeringenkast en zet de plug-ins. createBundle() doet wat je zou verwachten van de naam, dat is de bundeling van de code. Nogmaals, het verschil van wat we deden voordat we de inbedding van beide functies in de verschillende functies die zijn vervat in de context object.

We willen onze taak loper om taken te kunnen uitvoeren, toch? Hier zijn een paar voorbeelden die we kunnen definiëren:

taak(“schoon” is, () => src(“dist”).schoon(“dist”).exec());
taak(“default”, [“schoon”], async (context) => {
const zekering = context.bb();
zekering.dev();
de context.createBundle(zekering);
wachten op de zekering.run()
});

De eerste taak zal zijn verantwoordelijk voor het schoonmaken van de dist-directory. Het eerste argument is de naam van de taak, terwijl de tweede is de functie die wordt aangeroepen wanneer de taak wordt uitgevoerd.
Bel de eerste taak, we doen knooppunt zekering reinigen van de terminal.

Wanneer een taak is van default (dat is het eerste argument als in de tweede taak), die taak is er een die krijgt standaard de naam bij het uitvoeren van knooppunt zekering — in dit geval, dat is de tweede taak in onze configuratie. Andere taken moeten worden zal moeten worden expliciet genoemd in de terminal, zoals node zekering <task_name>.

Dus, onze tweede taak is de standaard en drie argumenten worden doorgegeven in. De eerste is de naam van de taak (`default`), de tweede ([“schoon”]) is een array van afhankelijkheden die moet worden aangeroepen voordat de taak zelf wordt uitgevoerd, en de derde is een functie (zekering.dev()) krijgt dat de geïnitialiseerd Zekeringenkast aanleg en begint de bundeling en het proces van het bouwen.

Nu kunnen we dingen met node zekering in de terminal. Je hebt de optie om deze toe te voegen aan uw pakket.json-bestand als dat meer is comfortabel en vertrouwd voor u. Het script zou er als volgt uitzien:

“scripts”: {
“start”: “node-zekering”,
“schone”: “node-zekering schoon”
},

Dat is een wrap!

Al met al, Zekeringenkast is een interessant alternatief voor de webpack voor al uw toepassing bundeling van behoeften. Zoals we zagen, het biedt dezelfde soort kracht die we allemaal de neiging om over webpack, maar met een veel minder ingewikkelde proces dat maakt het veel gemakkelijker aan de slag kunnen, dankzij de ingebouwde Typoscript ondersteuning, prestaties, en een taak loper die is ontworpen om te profiteren van de Zekeringenkast API.

Wat je ziet is een vrij eenvoudig voorbeeld. In de praktijk, bent u waarschijnlijk gaat om het werken met de meer complexe toepassingen, maar de concepten en principes zijn hetzelfde. Het is leuk om te weten dat Zekeringenkast is geschikt voor het verwerken van meer dan gebakken, maar dat de initiële setup is nog steeds super gestroomlijnd.

Als u op zoek bent naar meer informatie over de Zekeringenkast, het terrein en de documentatie zijn natuurlijk een prima uitgangspunt. de volgende links zijn ook super handig om te krijgen meer zicht op hoe anderen het instellen en gebruiken in projecten.

  • De invoering van Zekeringenkast, een alternatief voor de Webpack
  • WebPack is niet de enige manier
  • Inleiding tot de Zekeringenkast (YouTube)