or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

build-system.mdconfiguration.mdfilesystem.mdindex.mdtypescript.mdvalidation.md
tile.json

tessl/npm-sveltejs--package

A specialized build tool for creating Svelte component libraries and packages

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@sveltejs/package@2.5.x

To install, run

npx @tessl/cli install tessl/npm-sveltejs--package@2.5.0

index.mddocs/

@sveltejs/package

@sveltejs/package is a specialized build tool for creating Svelte component libraries and packages. It automates the complex packaging process by preprocessing Svelte components, transpiling TypeScript files to JavaScript, generating comprehensive type definitions (.d.ts files), and creating a properly structured dist directory with all necessary library files.

Package Information

  • Package Name: @sveltejs/package
  • Package Type: npm
  • Language: JavaScript/TypeScript
  • Installation: npm install -D @sveltejs/package

Core Imports

Important: This package is primarily a CLI tool (svelte-package command). The package.json exports field only includes "./package.json" - no programmatic APIs are officially exported.

For programmatic usage, you must import directly from source files:

// Core build functions
import { build, watch } from "@sveltejs/package/src/index.js";

// Configuration utilities  
import { load_config, load_pkg_json } from "@sveltejs/package/src/config.js";

// File system utilities
import { mkdirp, rimraf, copy, walk, posixify } from "@sveltejs/package/src/filesystem.js";

// TypeScript processing
import { emit_dts, transpile_ts } from "@sveltejs/package/src/typescript.js";

// Validation system
import { create_validator } from "@sveltejs/package/src/validate.js";

// Build utilities
import { resolve_aliases, strip_lang_tags, write, scan, analyze } from "@sveltejs/package/src/utils.js";

Note: These direct imports access internal implementation files that are not part of the public API. They may change between versions without notice.

Basic Usage

CLI Usage

# Basic package build
npx svelte-package

# Build with custom input and output directories
npx svelte-package -i src/lib -o dist

# Build without TypeScript declarations
npx svelte-package --types false

# Watch mode for development
npx svelte-package --watch

Programmatic Usage

import { build } from "@sveltejs/package/src/index.js";
import { load_config } from "@sveltejs/package/src/config.js";

const config = await load_config();

await build({
  cwd: process.cwd(),
  input: "src/lib",
  output: "dist",
  preserve_output: false,
  types: true,
  config
});

Architecture

@sveltejs/package is built around several key components:

  • CLI Interface: Command-line tool with sade for parsing arguments and configuration
  • Build System: Core build and watch functions for processing source files
  • File Processing Pipeline: Multi-stage processing for Svelte, TypeScript, and other files
  • TypeScript Integration: Transpilation and declaration file generation
  • Configuration System: Svelte config loading and validation
  • Validation Engine: Package.json exports validation and compliance checking

Capabilities

Build System

Core build functionality for processing Svelte packages with support for TypeScript, preprocessing, and file watching.

function build(options: Options): Promise<void>;

function watch(options: Options): Promise<WatchResult>;

interface WatchResult {
  watcher: chokidar.FSWatcher;
  ready: Promise<void>;
  settled(): Promise<void>;
}

Build System

Configuration Management

Configuration loading and validation for Svelte projects with support for multiple config file formats.

function load_config(options?: { cwd?: string }): Promise<Config>;

function load_pkg_json(cwd?: string): Record<string, any>;

interface Config {
  extensions?: string[];
  kit?: {
    alias?: Record<string, string>;
    files?: {
      lib?: string;
    };
    outDir?: string;
  };
  preprocess?: PreprocessorGroup;
}

Configuration Management

File System Utilities

File system operations including directory creation, recursive deletion, and file copying with cross-platform path handling.

function mkdirp(dir: string): void;

function rimraf(path: string): void;

function copy(source: string, target: string, opts?: CopyOptions): void;

function walk(cwd: string, dirs?: boolean): string[];

function posixify(str: string): string;

File System Utilities

TypeScript Processing

TypeScript compilation and declaration file generation with support for custom tsconfig files and path alias resolution.

function emit_dts(
  input: string,
  output: string,
  final_output: string,
  cwd: string,
  alias: Record<string, string>,
  files: File[],
  tsconfig?: string
): Promise<void>;

function transpile_ts(
  tsconfig: string | undefined,
  filename: string,
  source: string
): Promise<string>;

TypeScript Processing

Package Validation

Validation system for package.json exports fields and Svelte-specific configuration compliance.

function create_validator(options: Options): ValidatorResult;

interface ValidatorResult {
  analyse_code(name: string, code: string): void;
  validate(): void;
}

Package Validation

Types

import { PreprocessorGroup } from 'svelte/types/compiler/preprocess';
import { FSWatcher } from 'chokidar';

interface Options {
  cwd: string;
  input: string;
  output: string;
  preserve_output: boolean;
  types: boolean;
  tsconfig?: string;
  config: Config;
}

interface File {
  name: string;
  dest: string;
  base: string;
  is_svelte: boolean;
}

interface Config {
  extensions?: string[];
  kit?: {
    alias?: Record<string, string>;
    files?: {
      lib?: string;
    };
    outDir?: string;
  };
  preprocess?: PreprocessorGroup;
}

interface ValidatedConfig {
  extensions: string[];
  kit?: any;
  preprocess?: any;
}

interface WatchResult {
  watcher: FSWatcher;
  ready: Promise<void>;
  settled(): Promise<void>;
}

interface ValidatorResult {
  analyse_code(name: string, code: string): void;
  validate(): void;
}

interface CopyOptions {
  filter?: (basename: string) => boolean;
  replace?: Record<string, string>;
}

type RecursiveRequired<T> = {
  [K in keyof T]-?: Extract<T[K], Function> extends never
    ? RecursiveRequired<T[K]>
    : T[K];
};

type Validator<T = any> = (input: T, keypath: string) => T;