@packall/core 0.0.1 → 0.2.0

package/dist/schemas/package-json.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The package.json blocks `--file` reads, and what counts as readable.
+ *
+ * A narrow view on purpose: the only thing this tool wants from a package.json
+ * is which packages it declares. Everything else — `scripts`, `exports`, the
+ * half of the file that belongs to a bundler — is none of its business, and a
+ * schema that insisted on understanding it would reject files that are fine.
+ *
+ * Every block is optional and every wrongly-typed one is simply absent, so a
+ * hand-edited manifest produces a smaller spec list rather than a crash. That
+ * is what `tolerant` buys: a `dependencies: "all of them"` loses one block, not
+ * the file.
+ */
+import * as Schema from "effect/Schema";
+export declare const PackageJsonSchema: Schema.Struct<{
+    readonly dependencies: Schema.optional<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.$Record<Schema.String, Schema.Unknown>, never, never>>, never>>;
+    readonly devDependencies: Schema.optional<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.$Record<Schema.String, Schema.Unknown>, never, never>>, never>>;
+    readonly optionalDependencies: Schema.optional<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.$Record<Schema.String, Schema.Unknown>, never, never>>, never>>;
+    readonly peerDependencies: Schema.optional<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.decodeTo<Schema.$Record<Schema.String, Schema.String>, Schema.$Record<Schema.String, Schema.Unknown>, never, never>>, never>>;
+    readonly peerDependenciesMeta: Schema.optional<Schema.middlewareDecoding<Schema.UndefinedOr<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly optional: Schema.Boolean;
+    }>>, Schema.$Record<Schema.String, Schema.Unknown>, never, never>>, never>>;
+}>;
+export type PackageJson = typeof PackageJsonSchema.Type;
+export declare const decodePackageJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => import("effect/Option").Option<{
+    readonly dependencies?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly devDependencies?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly optionalDependencies?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly peerDependencies?: {
+        readonly [x: string]: string;
+    } | undefined;
+    readonly peerDependenciesMeta?: {
+        readonly [x: string]: {
+            readonly optional: boolean;
+        };
+    } | undefined;
+}>;
+//# sourceMappingURL=package-json.d.ts.map

package/dist/schemas/package-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-json.d.ts","sourceRoot":"","sources":["../../src/schemas/package-json.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,eAAO,MAAM,iBAAiB;;;;;;;;EAM5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAC;AAExD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;EAAgD,CAAC"}

package/dist/{Spec.d.ts → spec.d.ts}

@@ -1,4 +1,4 @@
-import { InvalidSpecError } from "./Errors.js";
+import { InvalidSpecError } from "./errors.js";
 /** How a spec narrows down which version(s) of a package we want. */
 export type Selector = 
 /** An exact, fully-qualified version: `react@18.2.0`. */
@@ -17,14 +17,14 @@ export type Selector =
     readonly tag: string;
 };
 /** A parsed, validated package spec. */
-export interface PackageSpec {
+export type PackageSpec = {
     /** The npm package name, including scope. */
     readonly name: string;
     /** What the user asked for after the `@`. */
     readonly selector: Selector;
     /** The original string, kept verbatim for error messages and the manifest. */
     readonly raw: string;
-}
+};
 /** Renders a spec back into the canonical `name@selector` form. */
 export declare const formatSpec: (spec: PackageSpec) => string;
 /** Human-readable form of just the selector part. */
@@ -59,4 +59,4 @@ export declare const parseSpecs: (inputs: ReadonlyArray<string>) => {
  * download React twice.
  */
 export declare const dedupeSpecs: (specs: ReadonlyArray<PackageSpec>) => ReadonlyArray<PackageSpec>;
-//# sourceMappingURL=Spec.d.ts.map
+//# sourceMappingURL=spec.d.ts.map

package/dist/spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../src/spec.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,qEAAqE;AACrE,MAAM,MAAM,QAAQ;AACnB,yDAAyD;AACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE;AACtD,gEAAgE;GAC9D;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AACpD,qDAAqD;GACnD;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAElD,wCAAwC;AACxC,MAAM,MAAM,WAAW,GAAG;IACzB,6CAA6C;IAC7C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,8EAA8E;IAC9E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACrB,CAAC;AASF,mEAAmE;AACnE,eAAO,MAAM,UAAU,SAAU,WAAW,KAAG,MACC,CAAC;AAEjD,qDAAqD;AACrD,eAAO,MAAM,cAAc,aAAc,QAAQ,KAAG,MASnD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,mBAAmB,SAAU,MAAM,KAAG,MAAM,GAAG,IA0B3D,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,QAAS,MAAM,KAAG,WAqBvC,CAAC;AAEF,qFAAqF;AACrF,eAAO,MAAM,aAAa,QAAS,MAAM,QAAQ,MAAM,KAAG,QAqBzD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,WACd,aAAa,CAAC,MAAM,CAAC,KAC3B;IACF,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;CAgBjD,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,UAAW,aAAa,CAAC,WAAW,CAAC,KAAG,aAAa,CAAC,WAAW,CAUxF,CAAC"}

package/dist/types/value-of.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The union of an object's value types.
+ *
+ * The companion to the `as const` object-enum pattern used throughout this
+ * package: the object is the value, `ValueOf<typeof X>` is the type, and the two
+ * share one name.
+ */
+export type ValueOf<T> = T[keyof T];
+//# sourceMappingURL=value-of.d.ts.map

package/dist/types/value-of.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-of.d.ts","sourceRoot":"","sources":["../../src/types/value-of.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC"}

package/dist/utils/is-record.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Narrows an unknown value to a plain object.
+ *
+ * The entry point for reading anything the tool does not control — lockfiles,
+ * package.json files, registry responses — without reaching for a cast.
+ */
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+//# sourceMappingURL=is-record.d.ts.map

package/dist/utils/is-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-record.d.ts","sourceRoot":"","sources":["../../src/utils/is-record.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,UAAW,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CACJ,CAAC"}

package/package.json

@@ -1,35 +1,37 @@
 {
   "name": "@packall/core",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Registry-agnostic engine for bundling npm packages and their full dependency closure for offline import.",
   "license": "MIT",
+  "files": [
+    "dist",
+    "src"
+  ],
   "type": "module",
   "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
   "exports": {
     ".": "./dist/index.js",
+    "./node": "./dist/node/index.js",
     "./package.json": "./package.json"
   },
-  "files": [
-    "dist",
-    "src"
-  ],
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
     "semver": "^7.7.2",
-    "tar": "^7.5.1"
-  },
-  "peerDependencies": {
-    "effect": "4.0.0-beta.103"
+    "tar": "^7.5.1",
+    "yaml": "^2.8.1"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-beta.103",
     "@types/semver": "^7.7.1",
     "effect": "4.0.0-beta.103"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
+  "peerDependencies": {
+    "effect": "4.0.0-beta.103"
+  },
   "scripts": {
     "build": "tsdown && tsc -p tsconfig.build.json",
     "check": "tsc -p tsconfig.json",

package/src/archive.ts

@@ -0,0 +1,95 @@
+/**
+ * Turning a staged directory tree into a gzipped tarball.
+ *
+ * A service rather than a function, because packing is the one step that has
+ * to be implemented differently per platform. Everywhere else the engine
+ * reaches the disk through `effect/FileSystem`, which is what lets an in-memory
+ * filesystem carry the whole pipeline — but a tar writer is not filesystem
+ * access, it is a format, and `node-tar` reads the paths it is given with
+ * Node's own `fs` rather than through the injected service. Left as a direct
+ * call, packing would quietly bypass the abstraction the rest of the engine
+ * depends on, which stays invisible until something other than Node provides
+ * the filesystem.
+ *
+ * The implementations live outside this module — `@packall/core/node` for
+ * Node, a Web Streams writer in the browser — so nothing platform-specific is
+ * reachable from the engine's own graph.
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import type * as FileSystem from "effect/FileSystem";
+import type { PlatformError } from "effect/PlatformError";
+
+import type { ArchiveError } from "./errors.js";
+import * as Progress from "./progress.js";
+
+/** A finished archive. */
+export type ArchiveResult = {
+	readonly path: string;
+	readonly bytes: number;
+};
+
+/** What to pack, and where to put it. */
+export type CreateArchiveOptions = {
+	readonly cwd: string;
+	/** Entry paths, relative to `cwd`. */
+	readonly entries: ReadonlyArray<string>;
+	readonly outPath: string;
+	readonly gzipLevel?: number | undefined;
+};
+
+export declare namespace Archiver {
+	/** The packing backend. */
+	export type Service = {
+		/**
+		 * Packs `entries` (paths relative to `cwd`) into a gzipped tar at
+		 * `outPath`.
+		 *
+		 * Implementations must produce byte-identical output for identical inputs —
+		 * normalised uid/gid/mtime, entries in a stable order — because a security
+		 * team diffing two bundles, or re-deriving one from its manifest, is a
+		 * thing that actually happens.
+		 */
+		readonly create: (
+			options: CreateArchiveOptions,
+		) => Effect.Effect<ArchiveResult, ArchiveError | PlatformError, FileSystem.FileSystem>;
+	};
+}
+
+/** Service tag for archive creation. */
+export class Archiver extends Context.Service<Archiver, Archiver.Service>()(
+	"@packall/core/Archiver",
+) {}
+
+/**
+ * Packs an archive with whichever backend is installed.
+ *
+ * The progress events are emitted here rather than inside the backends, so
+ * every implementation reports identically and a new one cannot forget to.
+ */
+export const createArchive = (
+	options: CreateArchiveOptions,
+): Effect.Effect<
+	ArchiveResult,
+	ArchiveError | PlatformError,
+	Archiver | FileSystem.FileSystem | Progress.Progress
+> =>
+	Effect.gen(function* () {
+		const archiver = yield* Archiver;
+
+		yield* Progress.emit({
+			_tag: "ArchiveStarted",
+			path: options.outPath,
+			entryCount: options.entries.length,
+		});
+
+		const result = yield* archiver.create(options);
+
+		yield* Progress.emit({
+			_tag: "ArchiveCompleted",
+			path: result.path,
+			bytes: result.bytes,
+		});
+
+		return result;
+	});