@savvy-web/silk-core 0.1.0

package/schemas/VersioningSchemas.js

@@ -0,0 +1,87 @@
+import { Effect, Schema } from "effect";
+
+//#region src/schemas/VersioningSchemas.ts
+/**
+* Configuration for how private packages are handled during versioning.
+*
+* @remarks
+* When set to `false`, private packages are completely ignored.
+* When set to an object, `tag` and `version` control whether private packages
+* receive git tags and version bumps respectively.
+*
+* @since 0.2.0
+*/
+const PrivatePackagesConfig = Schema.Union([Schema.Struct({
+	tag: Schema.optional(Schema.Boolean),
+	version: Schema.optional(Schema.Boolean)
+}), Schema.Literal(false)]);
+/**
+* Snapshot release configuration for changesets.
+*
+* @remarks
+* Controls how snapshot versions are generated.
+* `useCalculatedVersion` prepends the calculated version to the snapshot tag.
+* `prereleaseTemplate` is a custom template string for snapshot version format.
+*
+* @since 0.2.0
+*/
+const SnapshotConfig = Schema.Struct({
+	useCalculatedVersion: Schema.optional(Schema.Boolean),
+	prereleaseTemplate: Schema.optional(Schema.String)
+});
+/**
+* Standard changesets configuration matching the `@changesets/config@4.0.0` spec.
+*
+* @remarks
+* Represents the parsed `.changeset/config.json` file. All fields are optional
+* to allow partial configs. Use {@link (SilkChangesetConfigFile:type)} when the Silk changelog
+* adapter is detected.
+*
+* @since 0.1.0
+*/
+/** @public */
+const ChangesetConfigFile = Schema.Struct({
+	changelog: Schema.optional(Schema.Union([
+		Schema.String,
+		Schema.Array(Schema.Unknown),
+		Schema.Literal(false)
+	])),
+	commit: Schema.optional(Schema.Union([
+		Schema.Boolean,
+		Schema.String,
+		Schema.Array(Schema.Unknown)
+	])),
+	fixed: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
+	linked: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
+	access: Schema.optional(Schema.Literals(["public", "restricted"])),
+	baseBranch: Schema.optional(Schema.String),
+	updateInternalDependencies: Schema.optional(Schema.Literals([
+		"patch",
+		"minor",
+		"major"
+	])),
+	ignore: Schema.optional(Schema.Array(Schema.String)),
+	privatePackages: Schema.optional(PrivatePackagesConfig),
+	prettier: Schema.optional(Schema.Boolean),
+	changedFilePatterns: Schema.optional(Schema.Array(Schema.String)),
+	bumpVersionsWithWorkspaceProtocolOnly: Schema.optional(Schema.Boolean),
+	snapshot: Schema.optional(SnapshotConfig)
+});
+/**
+* Extended changeset config for repos using the `@savvy-web/changesets` changelog adapter.
+*
+* @remarks
+* Extends {@link (ChangesetConfigFile:type)} with a `_isSilk` marker flag that is automatically
+* set to `true`. Detected by `ChangesetConfigReader` when the `changelog` field
+* references `@savvy-web/changesets`.
+*
+* @since 0.1.0
+*/
+/** @public */
+const SilkChangesetConfigFile = Schema.Struct({
+	...ChangesetConfigFile.fields,
+	_isSilk: Schema.Boolean.pipe(Schema.withDecodingDefaultType(Effect.succeed(true)), Schema.withConstructorDefault(Effect.succeed(true)))
+});
+
+//#endregion
+export { ChangesetConfigFile, SilkChangesetConfigFile };

package/schemas/WorkspaceAnalysisSchemas.js

@@ -0,0 +1,209 @@
+import { ChangesetConfigFile, SilkChangesetConfigFile } from "./VersioningSchemas.js";
+import { trimTrailingSlashes } from "../utils/TrailingSlash.js";
+import { Effect, Equal, Function, Hash, Option, Schema } from "effect";
+import { PublishConfig, PublishTarget, TagStyle, VersioningStrategy } from "@effected/workspaces";
+
+//#region src/schemas/WorkspaceAnalysisSchemas.ts
+const PublishProtocol = Schema.Literals(["npm", "jsr"]);
+const PublishTargetShorthand = Schema.Literals([
+	"npm",
+	"github",
+	"jsr"
+]);
+const PublishTargetObject = Schema.Struct({
+	protocol: PublishProtocol.pipe(Schema.withDecodingDefaultType(Effect.succeed("npm")), Schema.withConstructorDefault(Effect.succeed("npm"))),
+	registry: Schema.optional(Schema.String),
+	directory: Schema.optional(Schema.String),
+	access: Schema.optional(Schema.Literals(["public", "restricted"])),
+	provenance: Schema.optional(Schema.Boolean),
+	tag: Schema.optional(Schema.String)
+});
+/**
+* Silk-extended publishConfig schema.
+*
+* @remarks
+* Extends the base PublishConfig from `@effected/workspaces` (which covers the
+* npm standard fields — access, registry, directory, tag — and, as of kit
+* round 3, `linkDirectory`) with the Silk `targets` extension for
+* multi-registry publishing.
+*
+* @since 0.2.0
+* @public
+*/
+var SilkPublishConfig = class extends PublishConfig.extend("SilkPublishConfig")({ targets: Schema.optional(Schema.Array(Schema.Union([PublishTargetShorthand, PublishTargetObject]))) }) {};
+const KNOWN_REGISTRIES = {
+	npm: "https://registry.npmjs.org/",
+	github: "https://npm.pkg.github.com/",
+	jsr: "https://jsr.io/"
+};
+/**
+* Compare registry URLs ignoring a trailing slash. `SilkPublishability` resolves
+* targets from the bundler's `dist/prod/targets.json` binding, which writes
+* registry endpoints WITHOUT a trailing slash (`https://registry.npmjs.org`),
+* while `KNOWN_REGISTRIES` / `NPM_DEFAULT` use the trailing-slash form. Normalize
+* both sides so `hasTarget`/`targetFor` match regardless of which form a target
+* carries (binding-driven, placeholder, or access-branch fallback).
+*/
+const sameRegistry = (a, b) => trimTrailingSlashes(a) === trimTrailingSlashes(b);
+/**
+* The package's declared version. `current` is absent for a member whose manifest carries no
+* `version` — legal for a private package and the ordinary shape for a private monorepo root,
+* which `@effected/workspaces` discovers as a member rather than rejecting (its `missingVersion`
+* failure kind was retired in 0.19.0). Such a package has no version to bump, tag or stamp.
+*/
+const WorkspaceVersion = Schema.Struct({ current: Schema.optional(Schema.String) });
+/**
+* A fully analyzed workspace with publish targets, versioning status,
+* and release group membership.
+*
+* @since 0.2.0
+* @public
+*/
+var AnalyzedWorkspace = class AnalyzedWorkspace extends Schema.TaggedClass()("AnalyzedWorkspace", {
+	name: Schema.String,
+	version: WorkspaceVersion,
+	path: Schema.String,
+	root: Schema.Boolean,
+	publishConfig: Schema.NullOr(SilkPublishConfig),
+	publishable: Schema.Boolean,
+	targets: Schema.Array(PublishTarget),
+	versioned: Schema.Boolean,
+	tagged: Schema.Boolean,
+	released: Schema.Boolean,
+	linked: Schema.Array(Schema.suspend(() => AnalyzedWorkspace)),
+	fixed: Schema.Array(Schema.suspend(() => AnalyzedWorkspace))
+}) {
+	get isRoot() {
+		return this.root;
+	}
+	get isPublishable() {
+		return this.publishable;
+	}
+	get isReleasable() {
+		return this.released;
+	}
+	get isFixed() {
+		return this.fixed.length > 0;
+	}
+	get isLinked() {
+		return this.linked.length > 0;
+	}
+	publishesTo(registry) {
+		return this.targets.some((t) => sameRegistry(t.registry, registry));
+	}
+	hasTarget(shorthand) {
+		const registry = KNOWN_REGISTRIES[shorthand];
+		return registry !== void 0 && this.publishesTo(registry);
+	}
+	targetFor(registry) {
+		const found = this.targets.find((t) => sameRegistry(t.registry, registry));
+		return found ? Option.some(found) : Option.none();
+	}
+	[Equal.symbol](that) {
+		if (!(that instanceof AnalyzedWorkspace)) return false;
+		return this.name === that.name && this.path === that.path;
+	}
+	[Hash.symbol]() {
+		return Hash.optimize(Hash.combine(Hash.hash(this.name), Hash.hash(this.path)));
+	}
+	toString() {
+		return this.version.current === void 0 ? this.name : `${this.name}@${this.version.current}`;
+	}
+	toJSON() {
+		return {
+			_tag: "AnalyzedWorkspace",
+			name: this.name,
+			version: this.version,
+			path: this.path,
+			root: this.root,
+			publishable: this.publishable,
+			targets: this.targets,
+			versioned: this.versioned,
+			tagged: this.tagged,
+			released: this.released
+		};
+	}
+	static publishable(workspaces) {
+		return workspaces.filter((w) => w.publishable);
+	}
+	static releasable(workspaces) {
+		return workspaces.filter((w) => w.released);
+	}
+	static findByName;
+	/** Pretty-print an AnalyzedWorkspace instance. */
+	static pretty;
+};
+AnalyzedWorkspace.findByName = Function.dual(2, (workspaces, name) => {
+	const found = workspaces.find((w) => w.name === name);
+	return found ? Option.some(found) : Option.none();
+});
+AnalyzedWorkspace.pretty = Schema.toFormatter(AnalyzedWorkspace);
+const PackageManagerInfo = Schema.Struct({
+	type: Schema.Literals([
+		"npm",
+		"pnpm",
+		"yarn",
+		"bun"
+	]),
+	version: Schema.optional(Schema.String)
+});
+/**
+* Full workspace analysis result containing all analyzed workspaces
+* and project-level configuration.
+*
+* @since 0.2.0
+* @public
+*/
+var WorkspaceAnalysis = class WorkspaceAnalysis extends Schema.TaggedClass()("WorkspaceAnalysis", {
+	root: Schema.String,
+	runtime: Schema.Literals(["node", "bun"]),
+	packageManager: PackageManagerInfo,
+	workspaces: Schema.Array(AnalyzedWorkspace),
+	changesetConfig: Schema.NullOr(Schema.Union([SilkChangesetConfigFile, ChangesetConfigFile])),
+	versioning: Schema.NullOr(VersioningStrategy),
+	tagStrategy: Schema.NullOr(TagStyle)
+}) {
+	findWorkspace(name) {
+		const found = this.workspaces.find((w) => w.name === name);
+		return found ? Option.some(found) : Option.none();
+	}
+	get rootWorkspace() {
+		const root = this.workspaces.find((w) => w.root);
+		return root ? Option.some(root) : Option.none();
+	}
+	get publishableWorkspaces() {
+		return this.workspaces.filter((w) => w.publishable);
+	}
+	get versionedWorkspaces() {
+		return this.workspaces.filter((w) => w.versioned);
+	}
+	get taggedWorkspaces() {
+		return this.workspaces.filter((w) => w.tagged);
+	}
+	get releasableWorkspaces() {
+		return this.workspaces.filter((w) => w.released);
+	}
+	get isSilk() {
+		if (this.changesetConfig == null) return false;
+		return "_isSilk" in this.changesetConfig && this.changesetConfig._isSilk === true;
+	}
+	get hasChangesets() {
+		return this.changesetConfig != null;
+	}
+	[Equal.symbol](that) {
+		if (!(that instanceof WorkspaceAnalysis)) return false;
+		return this.root === that.root;
+	}
+	[Hash.symbol]() {
+		return Hash.optimize(Hash.hash(this.root));
+	}
+	toString() {
+		return `WorkspaceAnalysis(${this.root}, ${this.workspaces.length} workspaces)`;
+	}
+	/** Pretty-print a WorkspaceAnalysis instance. */
+	static pretty;
+};
+WorkspaceAnalysis.pretty = Schema.toFormatter(WorkspaceAnalysis);
+
+//#endregion
+export { AnalyzedWorkspace, SilkPublishConfig, WorkspaceAnalysis };

package/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.59.1"
+    }
+  ]
+}

package/utils/TrailingSlash.js

@@ -0,0 +1,21 @@
+//#region src/utils/TrailingSlash.ts
+/**
+* Trim trailing slashes from a string.
+*
+* @remarks
+* Trims trailing slashes with an index scan rather than `/\/+$/`. That regex is
+* unanchored at the start, so the engine retries the match from every position
+* and degrades to O(n²) on a string of many slashes (CodeQL `js/polynomial-redos`).
+* Only a trailing run of slashes is removed; interior slash runs are untouched.
+*
+* @since 0.1.0
+* @public
+*/
+const trimTrailingSlashes = (s) => {
+	let end = s.length;
+	while (end > 0 && s[end - 1] === "/") end -= 1;
+	return s.slice(0, end);
+};
+
+//#endregion
+export { trimTrailingSlashes };