zwitterion
1.0.0
เว็บเซิร์ฟเวอร์ dev ที่ให้คุณนำเข้าทุกอย่าง*
* หากคุณหมายถึงอะไร: JavaScript ES2015+, TypeScript, JSON, JSX, TSX, Assemblyscript, Rust, C, C ++, WebAssembly และในอนาคตสิ่งใดก็ตามที่รวบรวม JavaScript หรือ WebAssembly
Zwitterion ได้รับการออกแบบมาเพื่อแทนที่ทันทีสำหรับเซิร์ฟเวอร์การพัฒนาเว็บในปัจจุบันของคุณ
การปรับใช้การผลิตยังเป็นไปได้ผ่านการสร้างแบบคงที่
ตัวอย่างเช่นคุณสามารถเขียนสิ่งต่าง ๆ เช่นต่อไปนี้และใช้งานได้:
./index.html :
<!DOCTYPE html >
< html >
< head >
< script type =" module " src =" app.ts " > </ script >
</ head >
< body >
This is the simplest developer experience I've ever had!
</ body >
</ html > ./app.ts :
import { getHelloWorld } from './hello-world.ts' ;
const helloWorld : string = getHelloWorld ( ) ;
console . log ( helloWorld ) ; ./hello-world.ts :
export function getHelloWorld ( ) : string {
return 'Why hello there world!' ;
}มันใช้งานได้จริง
Zwitterion ช่วยให้คุณกลับไปสู่การพัฒนาเว็บวันเก่า ๆ ที่ดี
เพียงแค่เขียนซอร์สโค้ดของคุณในภาษาที่รองรับและเรียกใช้ในเบราว์เซอร์
นอกจากนี้ ... Zwitterion ไม่ใช่ Bundler มันหลีกเลี่ยงการรวมตัวกันเพื่อประสบการณ์ที่ง่ายกว่า
import * as stuff from 'library'; แทนที่จะ import * as stuff from '../node_modules/library/index.js'; )index.html บนเส้นทางที่ไม่มีการจัดการ)ติดตั้ง Zwitterion ในไดเรกทอรีที่คุณต้องการให้บริการไฟล์จาก:
npm install zwitterionเรียกใช้ zwitterion โดยการเข้าถึงการดำเนินการโดยตรงจากเทอร์มินัล:
node_modules/.bin/zwitterion
หรือจากสคริปต์ NPM:
{
...
"scripts": {
"start": "zwitterion"
}
...
}
ติดตั้ง Zwitterion ทั่วโลกเพื่อใช้ในโครงการ:
npm install -g zwitterionเรียกใช้ zwitterion จากเทอร์มินัล:
zwitterionหรือจากสคริปต์ NPM:
{
...
"scripts": {
"start": "zwitterion"
}
...
}
ขอแนะนำให้ใช้ Zwitterion ในการผลิตโดยการสร้างงานสร้างแบบคงที่ของโครงการของคุณ การสร้างแบบคงที่จะเรียกใช้ไฟล์ที่เกี่ยวข้องทั้งหมดผ่าน Zwitterion และคัดลอกไฟล์เหล่านั้นและไฟล์อื่น ๆ ทั้งหมดในโครงการของคุณไปยังไดเรกทอรี dist คุณสามารถใช้ไดเรกทอรีนี้และอัปโหลดไปยังเครือข่ายการส่งเนื้อหา (CDN) หรือบริการโฮสต์ไฟล์สแตติกอื่น
คุณอาจใช้เซิร์ฟเวอร์ Zwitterion ที่ใช้งานอยู่ในการผลิต แต่สำหรับประสิทธิภาพและเหตุผลด้านความปลอดภัยที่อาจเกิดขึ้นไม่แนะนำ
ในการสร้างงานสร้างแบบคงที่ให้เรียกใช้ zwitterion ด้วยตัวเลือก --build-static คุณอาจต้องเพิ่มประเภท MIME application/javascript ให้กับผู้ให้บริการโฮสติ้งของคุณสำหรับไฟล์ typeScript, Assemblyscript, Rust, WASM และ WAT
จากเทอร์มินัล:
zwitterion --build-staticจากสคริปต์ NPM:
{
...
" scripts " : {
" build-static " : " zwitterion --build-static "
}
...
} การสร้างแบบคงที่จะอยู่ในไดเรกทอรีที่เรียกว่า dist ในไดเรกทอรีเดียวกันกับที่คุณใช้คำสั่ง --build-static จาก
JavaScript เป็นภาษาของเว็บ คุณสามารถเรียนรู้เพิ่มเติมได้ที่นี่
การนำเข้า JavaScript ES2015+ นั้นตรงไปตรงมาและทำงานตามที่คาดไว้ เพียงใช้คำสั่งนำเข้าและส่งออกโดยไม่มีการแก้ไขใด ๆ ขอแนะนำให้ใช้ส่วนขยายไฟล์ที่ชัดเจน:
./app.js :
import { helloWorld } from './hello-world.js' ;
console . log ( helloWorld ( ) ) ; ./hello-world.js :
export function helloWorld ( ) {
return 'Hello world!' ;
} JavaScript transpilation ทำโดยคอมไพเลอร์ TypeScript โดยค่าเริ่มต้น compilerOptions ของ TypeScript Compiler ถูกตั้งค่าเป็นดังต่อไปนี้:
{
"module" : " ES2015 " ,
"target" : " ES2015 "
} คุณสามารถแทนที่ตัวเลือกเหล่านี้ได้โดยการสร้างไฟล์ .json ด้วย compilerOptions ของคุณเองและบอก zwitterion ว่าจะค้นหาได้ที่ไหนด้วยตัวเลือกบรรทัดคำสั่ง --tsc-options-file ตัวเลือกที่มีอยู่สามารถพบได้ที่นี่ ตัวเลือกถูกระบุเป็นวัตถุ JSON ตัวอย่างเช่น:
tsc-options.json :
{
"target" : " ES5 "
}บอก Zwitterion ว่าจะหาที่ไหน:
zwitterion --tsc-options-file tsc-options.jsonTypeScript เป็น superset ที่พิมพ์ของ JavaScript คุณสามารถเรียนรู้เพิ่มเติมได้ที่นี่
การนำเข้า TypeScript นั้นตรงไปตรงมาและทำงานตามที่คาดไว้ เพียงใช้คำสั่งนำเข้าและส่งออกโดยไม่มีการแก้ไขใด ๆ ขอแนะนำให้ใช้ส่วนขยายไฟล์ที่ชัดเจน:
./app.ts :
import { helloWorld } from './hello-world.ts' ;
console . log ( helloWorld ( ) ) ; ./hello-world.ts :
export function helloWorld ( ) : string {
return 'Hello world!' ;
} โดยค่าเริ่มต้น compilerOptions ของ TypeScript Compiler ถูกตั้งค่าเป็นดังต่อไปนี้:
{
"module" : " ES2015 " ,
"target" : " ES2015 "
} คุณสามารถแทนที่ตัวเลือกเหล่านี้ได้โดยการสร้างไฟล์ .json ด้วย compilerOptions ของคุณเองและบอก zwitterion ว่าจะค้นหาได้ที่ไหนด้วยตัวเลือกบรรทัดคำสั่ง --tsc-options-file ตัวเลือกที่มีอยู่สามารถพบได้ที่นี่ ตัวเลือกถูกระบุเป็นวัตถุ JSON ตัวอย่างเช่น:
tsc-options.json :
{
"target" : " ES5 "
}บอก Zwitterion ว่าจะหาที่ไหน:
zwitterion --tsc-options-file tsc-options.jsonJSON มีให้เป็นการส่งออกเริ่มต้น ขอแนะนำให้ใช้ส่วนขยายไฟล์ที่ชัดเจน:
./app.js :
import helloWorld from './hello-world.json' ;
console . log ( helloWorld ) ; ./hello-world.json :
{
"hello" : " world "
}การนำเข้า JSX นั้นตรงไปตรงมาและทำงานตามที่คาดไว้ เพียงใช้คำสั่งนำเข้าและส่งออกโดยไม่มีการแก้ไขใด ๆ ขอแนะนำให้ใช้ส่วนขยายไฟล์ที่ชัดเจน:
./app.js :
import { helloWorldElement } from './hello-world.jsx' ;
ReactDOM . render (
helloWorldElement ,
document . getElementById ( 'root' )
) ; ./hello-world.jsx :
export const hellowWorldElement = < h1 > Hello, world! </ h1 > ; JSX transpilation ทำโดยคอมไพเลอร์ TypeScript โดยค่าเริ่มต้น compilerOptions ของ TypeScript Compiler ถูกตั้งค่าเป็นดังต่อไปนี้:
{
"module" : " ES2015 " ,
"target" : " ES2015 "
} คุณสามารถแทนที่ตัวเลือกเหล่านี้ได้โดยการสร้างไฟล์ .json ด้วย compilerOptions ของคุณเองและบอก zwitterion ว่าจะค้นหาได้ที่ไหนด้วยตัวเลือกบรรทัดคำสั่ง --tsc-options-file ตัวเลือกที่มีอยู่สามารถพบได้ที่นี่ ตัวเลือกถูกระบุเป็นวัตถุ JSON ตัวอย่างเช่น:
tsc-options.json :
{
"target" : " ES5 "
}บอก Zwitterion ว่าจะหาที่ไหน:
zwitterion --tsc-options-file tsc-options.jsonการนำเข้า TSX นั้นตรงไปตรงมาและทำงานตามที่คาดไว้ เพียงใช้คำสั่งนำเข้าและส่งออกโดยไม่มีการแก้ไขใด ๆ ขอแนะนำให้ใช้ส่วนขยายไฟล์ที่ชัดเจน:
./app.js :
import { helloWorldElement } from './hello-world.tsx' ;
ReactDOM . render (
helloWorldElement ,
document . getElementById ( 'root' )
) ; ./hello-world.tsx :
const helloWorld : string = 'Hello, world!' ;
export const hellowWorldElement = < h1 > { helloWorld } </ h1 > ; TSX transpilation ทำโดยคอมไพเลอร์ TypeScript โดยค่าเริ่มต้น compilerOptions ของ TypeScript Compiler ถูกตั้งค่าเป็นดังต่อไปนี้:
{
"module" : " ES2015 " ,
"target" : " ES2015 "
} คุณสามารถแทนที่ตัวเลือกเหล่านี้ได้โดยการสร้างไฟล์ .json ด้วย compilerOptions ของคุณเองและบอก zwitterion ว่าจะค้นหาได้ที่ไหนด้วยตัวเลือกบรรทัดคำสั่ง --tsc-options-file ตัวเลือกที่มีอยู่สามารถพบได้ที่นี่ ตัวเลือกถูกระบุเป็นวัตถุ JSON ตัวอย่างเช่น:
tsc-options.json :
{
"target" : " ES5 "
}บอก Zwitterion ว่าจะหาที่ไหน:
zwitterion --tsc-options-file tsc-options.jsonAssemblyscript เป็นภาษาใหม่ที่รวบรวมชุดย่อยที่เข้มงวดของ TypeScript ไปยัง WebAssembly คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับเรื่องนี้ได้ในหนังสือแอสเซมบลิคสคริปต์
Zwitterion สันนิษฐานว่าไฟล์แอสเซมบลิส .as มีส่วนขยายไฟล์. นี่คือตัวเลือกส่วนขยายเฉพาะของ Zwitterion เนื่องจากโครงการแอสเซมบลิคสคริปต์ยังไม่ได้เลือกนามสกุลไฟล์อย่างเป็นทางการของตัวเอง คุณสามารถติดตามการสนทนาที่นี่ Zwitterion จะติดตามตัวเลือกส่วนขยายอย่างเป็นทางการเมื่อมีการสร้าง
การนำเข้าแอสเซมบลีสคริปต์เกือบจะเหมือนกับการนำเข้า JavaScript หรือ TypeScript ความแตกต่างที่สำคัญคือการส่งออกเริ่มต้นของโมดูลแอสเซมบลีสคริปต์รายการของคุณคือฟังก์ชั่นที่ส่งคืนสัญญา ฟังก์ชั่นนี้ใช้เป็นหนึ่งพารามิเตอร์วัตถุที่มีการนำเข้าไปยังโมดูล Assemblyscript
การส่งผ่านไปยังและจากฟังก์ชั่นที่ส่งออกจากโมดูลแอสเซมบลิคสคริปต์ควรตรงไปตรงมา แต่มีข้อ จำกัด บางประการ Zwitterion ใช้ As-Bind ภายใต้ฮูดถึงค่านายหน้าไปและจากโมดูลแอสเซมบลิคสคริปต์ ดูที่นั่นหากคุณต้องการข้อมูลเพิ่มเติม
คุณสามารถนำเข้า Assemblyscript จาก JavaScript หรือไฟล์ typeScript เช่นนี้:
./app.js :
import addModuleInit from './add.as' ;
runAssemblyScript ( ) ;
async function runAssemblyScript ( ) {
const adddModule = await addModuleInit ( ) ;
console . log ( addModule . add ( 1 , 1 ) ) ;
} ./add.as :
export function add ( x : i32 , y : i32 ) : i32 {
return x + y ;
}หากคุณต้องการส่งผ่านการนำเข้าจากด้านนอกของสภาพแวดล้อมแอสเซมบลีสคริปต์คุณจะสร้างไฟล์ที่มีประกาศส่งออกที่กำหนดประเภทของการนำเข้า จากนั้นคุณส่งการนำเข้าของคุณเป็นวัตถุไปยังฟังก์ชัน assemblyscript module init ชื่อของคุณสมบัติที่กำหนดการนำเข้าของคุณสำหรับโมดูลจะต้องเป็นชื่อไฟล์ที่แน่นอนของไฟล์ที่ส่งออกประกาศนำเข้า ตัวอย่างเช่น:
./app.js :
import addModuleInit from './add.as' ;
runAssemblyScript ( ) ;
async function runAssemblyScript ( ) {
const adddModule = await addModuleInit ( {
'env.as' : {
log : console . log
}
} ) ;
console . log ( addModule . add ( 1 , 1 ) ) ;
} ./env.as :
export declare function log ( x : number ) : void ; ./add.as :
import { log } from './env.as' ;
export function add ( x : i32 , y : i32 ) : i32 {
log ( x + y ) ;
return x + y ;
}นอกจากนี้คุณยังสามารถนำเข้า assemblyscript จากภายในไฟล์ assemblyscript เช่น So:
./add.as :
import { subtract } from './subtract.as' ;
export function add ( x : i32 , y : i32 ) : i32 {
return subtract ( x + y , 0 ) ;
} ./subtract.as :
export function subtract ( x : i32 , y : i32 ) : i32 {
return x - y ;
} โดยค่าเริ่มต้นจะไม่มีการตั้งค่าตัวเลือกคอมไพเลอร์ ตัวเลือกที่มีอยู่สามารถพบได้ที่นี่ คุณสามารถเพิ่มตัวเลือกได้โดยการสร้างไฟล์ .json ด้วยอาร์เรย์ของชื่อตัวเลือกและค่านิยมและบอก zwitterion ว่าจะค้นหาได้ที่ไหนด้วยตัวเลือกบรรทัดคำสั่ง --asc-options-file ตัวอย่างเช่น:
./asc-options.json :
[
" --optimizeLevel " , " 3 " ,
" --runtime " , " none " ,
" --shrinkLevel " , " 2 "
]บอก Zwitterion ว่าจะหาที่ไหน:
zwitterion --asc-options-file asc-options.jsonRust เป็นภาษาระดับต่ำที่มุ่งเน้นไปที่ประสิทธิภาพความน่าเชื่อถือและผลผลิต เรียนรู้เพิ่มเติมที่นี่
การสนับสนุนสนิมในปัจจุบันเป็นพื้นฐานมาก (เช่นไม่มีการสนับสนุน wasm-bindgen) คุณต้องติดตั้งสนิมบนเครื่องของคุณ คุณสามารถค้นหาคำแนะนำสำหรับการติดตั้ง Rust ได้ที่นี่ มันเป็นเป้าหมายของ Zwitterion ในการติดตั้งเครื่องมือ Rust Tooling ที่จำเป็นเมื่อติดตั้ง Zwitterion โดยอัตโนมัติ แต่ปัจจุบันเป็นงานที่กำลังดำเนินการอยู่
การนำเข้าสนิมเกือบจะเหมือนกับการนำเข้า JavaScript หรือ TypeScript ความแตกต่างที่สำคัญคือการส่งออกเริ่มต้นของโมดูล Rust รายการของคุณเป็นฟังก์ชั่นที่ส่งคืนสัญญา ฟังก์ชั่นนี้ใช้เป็นหนึ่งพารามิเตอร์วัตถุที่มีการนำเข้าไปยังโมดูลสนิม คุณสามารถนำเข้าสนิมจากไฟล์ JavaScript หรือ TypeScript เช่นนี้:
./app.js
import addModuleInit from './add.rs' ;
runRust ( ) ;
async function runRust ( ) {
const addModule = await addModuleInit ( ) ;
console . log ( addModule . add ( 5 , 5 ) ) ;
} ./add.rs
#! [ no_main ]
# [ no_mangle ]
pub fn add ( x : i32 , y : i32 ) -> i32 {
return x + y ;
}การสนับสนุน C ปัจจุบันเป็นพื้นฐานมาก คุณต้องติดตั้ง emscripten บนเครื่องของคุณ คุณสามารถค้นหาคำแนะนำสำหรับการติดตั้ง emscripten ได้ที่นี่ มันเป็นเป้าหมายของ zwitterion ในการติดตั้งเครื่องมือ C ที่จำเป็นในท้องถิ่นโดยอัตโนมัติเมื่อติดตั้ง Zwitterion แต่ปัจจุบันเป็นงานที่กำลังดำเนินการอยู่
การนำเข้า C เกือบจะเหมือนกับการนำเข้า JavaScript หรือ TypeScript ความแตกต่างที่สำคัญคือการส่งออกเริ่มต้นของโมดูลรายการ C ของคุณคือฟังก์ชั่นที่ส่งคืนสัญญา ฟังก์ชั่นนี้ใช้เป็นหนึ่งพารามิเตอร์วัตถุที่มีการนำเข้าไปยังโมดูล C คุณสามารถนำเข้า C จากไฟล์ JavaScript หรือ TypeScript เช่นนี้:
./app.js
import addModuleInit from './add.c' ;
runC ( ) ;
async function runC ( ) {
const addModule = await addModuleInit ( ) ;
console . log ( addModule . add ( 5 , 5 ) ) ;
} ./add.c
int add ( int x , int y ) {
return x + y ;
}การสนับสนุน C ++ ปัจจุบันเป็นพื้นฐานมาก คุณต้องติดตั้ง emscripten บนเครื่องของคุณ คุณสามารถค้นหาคำแนะนำสำหรับการติดตั้ง emscripten ได้ที่นี่ มันเป็นเป้าหมายของ Zwitterion ในการติดตั้งเครื่องมือ C ++ ที่จำเป็นในเครื่องโดยอัตโนมัติเมื่อติดตั้ง Zwitterion แต่ปัจจุบันเป็นงานที่กำลังดำเนินการอยู่
การนำเข้า C ++ เกือบจะเหมือนกับการนำเข้า JavaScript หรือ TypeScript ความแตกต่างที่สำคัญคือการส่งออกเริ่มต้นของโมดูลรายการ C ++ ของคุณเป็นฟังก์ชั่นที่ส่งคืนสัญญา ฟังก์ชั่นนี้ใช้เป็นหนึ่งพารามิเตอร์วัตถุที่มีการนำเข้าไปยังโมดูล C ++ คุณสามารถนำเข้า C ++ จากไฟล์ JavaScript หรือ typeScript เช่นนี้:
./app.js
import addModuleInit from './add.cpp' ;
runCPP ( ) ;
async function runCPP ( ) {
const addModule = await addModuleInit ( ) ;
console . log ( addModule . add ( 5 , 5 ) ) ;
} ./add.cpp
extern " C " {
int add ( int x, int y) {
return x + y;
}
}
วัดเป็นตัวแทนที่เป็นรูปแบบของรูปแบบไบนารี WASM ช่วยให้ WASM เขียนได้ง่ายขึ้นด้วยมือ เรียนรู้เพิ่มเติมที่นี่
การนำเข้าวัดเกือบจะเหมือนกับการนำเข้า JavaScript หรือ TypeScript ความแตกต่างที่สำคัญคือการส่งออกเริ่มต้นของโมดูล WAT ของคุณเป็นฟังก์ชั่นที่ส่งคืนสัญญา ฟังก์ชั่นนี้ใช้เป็นหนึ่งพารามิเตอร์วัตถุที่มีการนำเข้าไปยังโมดูลวัด คุณสามารถนำเข้าวัดจาก JavaScript หรือไฟล์ typecript เช่นนี้:
./app.js
import addModuleInit from './add.wat' ;
runWat ( ) ;
async function runWat ( ) {
const addModule = await addModuleInit ( ) ;
console . log ( addModule . add ( 5 , 5 ) ) ;
} ./add.wat
(module
(func $add (param $x i32) (param $y i32) (result i32)
(i32.add (get_local $x) (get_local $y))
)
( export " add " (func $add))
)WASM เป็นรูปแบบคำสั่งไบนารีที่สร้างขึ้นเพื่อให้มีประสิทธิภาพปลอดภัยพกพาและเปิด เรียนรู้เพิ่มเติมที่นี่
การนำเข้า WASM เกือบจะเหมือนกับการนำเข้า JavaScript หรือ TypeScript ความแตกต่างที่สำคัญคือการส่งออกเริ่มต้นของโมดูล WASM ของคุณเป็นฟังก์ชั่นที่ส่งคืนสัญญา ฟังก์ชั่นนี้ใช้เป็นหนึ่งพารามิเตอร์วัตถุที่มีการนำเข้าไปยังโมดูล WASM คุณสามารถนำเข้า WASM จาก JavaScript หรือไฟล์ typeScript เช่นนี้:
./app.js
import addModuleInit from './add.wasm' ;
runWasm ( ) ;
async function runWasm ( ) {
const addModule = await addModuleInit ( ) ;
console . log ( addModule . add ( 5 , 5 ) ) ;
} ./add.wasm
Imagine this is a compiled Wasm binary file with a function called `add`
ระบุพอร์ตของเซิร์ฟเวอร์:
--port [port]สร้างการสร้างแบบคงที่ของไดเรกทอรีการทำงานปัจจุบัน ผลลัพธ์จะอยู่ในไดเรกทอรีที่เรียกว่า Dist ในไดเรกทอรีการทำงานปัจจุบัน:
--build-staticรายการเส้นทางที่คั่นด้วยเครื่องหมายจุลภาคซึ่งสัมพันธ์กับไดเรกทอรีปัจจุบันเพื่อแยกออกจากการสร้างแบบคงที่:
--exclude [exclude]รายการเส้นทางที่คั่นด้วยเครื่องหมายจุลภาคเทียบกับไดเรกทอรีปัจจุบันเพื่อรวมไว้ในการสร้างแบบคงที่
--include [include]พา ธ ไปยังไฟล์ที่สัมพันธ์กับไดเรกทอรีปัจจุบันเพื่อทำหน้าที่เป็นรูท SPA มันจะถูกส่งคืนสำหรับเส้นทางรูทและเมื่อไม่พบไฟล์:
--spa-root [spaRoot]ปิดใช้งานการเปลี่ยนเส้นทางสปาไปยัง index.html:
--disable-spaเส้นทางไปยังไฟล์ JSON เทียบกับไดเรกทอรีปัจจุบันสำหรับส่วนหัว HTTP ที่กำหนดเอง:
--headers-file [headersFile]ส่วนหัว HTTP ที่กำหนดเองถูกระบุเป็นวัตถุ JSON ที่มีรูปร่างต่อไปนี้:
type CustomHTTPHeaders = {
[ regexp : string ] : HTTPHeaders ;
}
type HTTPHeaders = {
[ key : string ] : string ;
}ตัวอย่างเช่น:
./headers.json
{
"^service-worker.ts$" : {
"Service-Worker-Allowed" : " / "
}
}เส้นทางไปยังไฟล์ JSON เทียบกับไดเรกทอรีปัจจุบันสำหรับตัวเลือกคอมไพเลอร์ TSC:
--tsc-options-file [tscOptionsFile]ตัวเลือกที่มีอยู่สามารถพบได้ที่นี่ ตัวเลือกถูกระบุเป็นวัตถุ JSON ตัวอย่างเช่น:
tsc-options.json :
{
"target" : " ES5 "
}เส้นทางไปยังไฟล์ JSON เทียบกับไดเรกทอรีปัจจุบันสำหรับตัวเลือกคอมไพเลอร์ ASC:
--asc-options-file [ascOptionsFile]โดยค่าเริ่มต้นจะไม่มีการตั้งค่าตัวเลือกคอมไพเลอร์ ตัวเลือกที่มีอยู่สามารถพบได้ที่นี่ ตัวเลือกถูกระบุเป็นอาร์เรย์ของชื่อตัวเลือกและค่า ตัวอย่างเช่น:
./asc-options.json :
[
" --optimizeLevel " , " 3 " ,
" --runtime " , " none " ,
" --shrinkLevel " , " 2 "
]แพ็คเกจของบุคคลที่สามจะต้องได้รับการเขียนราวกับว่าพวกเขาใช้ zwitterion โดยพื้นฐานแล้วนี่หมายความว่าพวกเขาควรได้รับการเขียนใน JavaScript หรือ typeScript มาตรฐานและ Assemblyscript, Rust, C และ C ++ จะต้องได้รับการเขียนตามเอกสารประกอบการประกอบเว็บของพวกเขา ข้อยกเว้นที่น่าสังเกตจะถูกอธิบายในเอกสารนี้ CommonJS (จำเป็นต้องใช้ไวยากรณ์), JSON, HTML หรือ CSS ES Module นำเข้าและคุณสมบัติอื่น ๆ ที่ไม่ได้มาตรฐานที่ Bundlers สนับสนุนโดยทั่วไปจะไม่ได้รับการสนับสนุนในซอร์สโค้ด
เป็นสิ่งสำคัญที่จะต้องทราบว่า Zwitterion สันนิษฐานว่าไฟล์รูท (ไฟล์ที่พบที่ / ) ของเว็บแอปพลิเคชันของคุณเป็นไฟล์ index.html เสมอ
Zwitterion ขึ้นอยู่กับการสนับสนุนเบราว์เซอร์เนทีฟสำหรับโมดูล ES (นำเข้า/ส่งออกไวยากรณ์) คุณต้องเพิ่มแอตทริบิวต์ type="module" ในองค์ประกอบสคริปต์ที่อ้างอิงโมดูลตัวอย่างเช่น:
<script type="module" src="amazing-module.ts"></script>
เป็นสิ่งสำคัญที่จะต้องทราบว่า Zwitterion ไม่รวมไฟล์หรือมีส่วนร่วมในการเขย่าต้นไม้ สิ่งนี้อาจส่งผลกระทบต่อประสิทธิภาพของแอปพลิเคชันของคุณ โมดูล HTTTP2 และ ES อาจช่วยในการแสดง แต่ ณ จุดนี้สัญญาณเวลามีแนวโน้มที่จะชี้ไปที่ประสิทธิภาพที่แย่ลง Zwitterion มีแผนที่จะปรับปรุงประสิทธิภาพโดยการสร้างข้อมูลการผลักดันเซิร์ฟเวอร์ HTTP2 โดยอัตโนมัติจากการสร้างแบบคงที่และมองหาการเขย่าต้นไม้ แต่ก็ไม่มีความชัดเจนว่าจะมีผลกระทบอะไร คอยติดตามข้อมูลเพิ่มเติมเกี่ยวกับประสิทธิภาพเมื่อ Zwitterion ครบกำหนด
จากทั้งหมดที่กล่าวมาข้างต้นความหมายของประสิทธิภาพไม่ชัดเจน วัดด้วยตัวคุณเอง
อ่านข้อมูลเพิ่มเติมต่อไปนี้เกี่ยวกับการรวมเข้ากับการรวมเข้ากับ HTTP2:
Zwitterion ง่าย มันเป็นเซิร์ฟเวอร์ไฟล์แบบคงที่มากหรือน้อย แต่จะเขียนไฟล์ที่ร้องขอในหน่วยความจำอีกครั้งตามความจำเป็นเพื่อกลับไปที่ไคลเอนต์ ตัวอย่างเช่นหากมีการร้องขอไฟล์ typeScript จากไคลเอนต์ Zwitterion จะดึงข้อความของไฟล์ให้รวบรวมเป็น JavaScript จากนั้นส่งคืนข้อความที่รวบรวมไปยังไคลเอนต์ สิ่งเดียวกันนี้ทำสำหรับไฟล์ JavaScript ในความเป็นจริงเกือบกระบวนการเดียวกันจะถูกใช้สำหรับส่วนขยายไฟล์ใด ๆ ที่เราต้องการสนับสนุนในอนาคต ตัวอย่างเช่นในอนาคตหากมีการร้องขอไฟล์ C มันจะถูกอ่านลงในหน่วยความจำข้อความจะถูกรวบรวมไปยัง WebAssembly และ WebAssembly จะถูกส่งกลับไปยังไคลเอนต์ การรวบรวมทั้งหมดนี้ทำฝั่งเซิร์ฟเวอร์และซ่อนตัวจากผู้ใช้ สำหรับผู้ใช้เป็นเพียงเซิร์ฟเวอร์ไฟล์แบบคงที่
