@effected/markdown 0.21.0 → 0.22.0

package/FrontmatterResolver.js

@@ -1,4 +1,4 @@
-import { Effect, Predicate, Result, Schema } from "effect";
+import { Effect, Option, Predicate, Result, Schema } from "effect";
 
 // src/FrontmatterResolver.ts
 /**
@@ -189,24 +189,11 @@ var SchemaResolver = class SchemaResolver {
 			value
 		}));
 	}
-	/**
-	* Extract and classify the `$schema` declaration from decoded frontmatter
-	* data.
-	*
-	* @remarks
-	* Non-mapping data and a mapping without a `$schema` key both carry no
-	* declaration: the result succeeds with `undefined` by default, or fails
-	* with {@link SchemaDeclarationMissingError} under `requireDeclaration`.
-	*
-	* @param data - The decoded frontmatter data.
-	* @param options - `requireDeclaration` makes a missing `$schema` a typed
-	*   error.
-	* @returns The classified declaration, `undefined` when absent and
-	*   tolerated, or the typed error.
-	*/
 	static declarationOf(data, options) {
-		if (!Predicate.isObject(data) || !Object.hasOwn(data, "$schema")) return options?.requireDeclaration === true ? Result.fail(new SchemaDeclarationMissingError()) : Result.succeed(void 0);
-		return SchemaResolver.classify(data.$schema);
+		const required = options?.requireDeclaration === true;
+		if (!Predicate.isObject(data) || !Object.hasOwn(data, "$schema")) return required ? Result.fail(new SchemaDeclarationMissingError()) : Result.succeed(Option.none());
+		const classified = SchemaResolver.classify(data.$schema);
+		return required ? classified : Result.map(classified, Option.some);
 	}
 	/**
 	* The package's one built-in resolver: a name-keyed registry with

package/index.d.ts

@@ -2251,19 +2251,34 @@ export declare class SchemaResolver {
    * data.
    *
    * @remarks
-   * Non-mapping data and a mapping without a `$schema` key both carry no
-   * declaration: the result succeeds with `undefined` by default, or fails
-   * with {@link SchemaDeclarationMissingError} under `requireDeclaration`.
+   * A lookup that can miss, so by default the success channel is an
+   * `Option`: non-mapping data and a mapping without a `$schema` key both
+   * carry no declaration and succeed with `Option.none()`, and the error
+   * union is {@link SchemaDeclarationInvalidError} alone. Under
+   * `requireDeclaration: true` the miss becomes a typed
+   * {@link SchemaDeclarationMissingError} and the success is the bare
+   * declaration, since it is statically always present. The two overloads
+   * keep each caller's types honest: no `Option` to unwrap when the
+   * declaration is required, no `SchemaDeclarationMissingError` to handle
+   * when it is not. A present key is classified by
+   * {@link SchemaResolver.classify}, and its
+   * {@link SchemaDeclarationInvalidError} propagates unchanged. Hand an
+   * optional declaration to a {@link FrontmatterSchemaResolver} with
+   * `Option.getOrUndefined`, since the seam takes the absent case as
+   * `undefined`; a required one passes straight through.
    *
    * @param data - The decoded frontmatter data.
-   * @param options - `requireDeclaration` makes a missing `$schema` a typed
-   *   error.
-   * @returns The classified declaration, `undefined` when absent and
-   *   tolerated, or the typed error.
+   * @param options - `requireDeclaration: true` makes a missing `$schema` a
+   *   typed error and narrows the success to the declaration itself.
+   * @returns The classified declaration under `requireDeclaration`;
+   *   otherwise `Option.some` of it, or `Option.none()` when absent.
    */
+  static declarationOf(data: unknown, options: {
+    readonly requireDeclaration: true;
+  }): Result.Result<SchemaDeclaration, SchemaDeclarationInvalidError | SchemaDeclarationMissingError>;
   static declarationOf(data: unknown, options?: {
-    readonly requireDeclaration?: boolean;
-  }): Result.Result<SchemaDeclaration | undefined, SchemaDeclarationInvalidError | SchemaDeclarationMissingError>;
+    readonly requireDeclaration?: false;
+  }): Result.Result<Option.Option<SchemaDeclaration>, SchemaDeclarationInvalidError>;
   /**
    * The package's one built-in resolver: a name-keyed registry with
    * exact version-segment resolution.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/markdown",
-	"version": "0.21.0",
+	"version": "0.22.0",
 	"private": false,
 	"description": "CommonMark and GFM markdown parse, edit and transform schemas for Effect",
 	"keywords": [
@@ -41,7 +41,7 @@
 	"peerDependencies": {
 		"@effected/jsonc": "^0.20.0",
 		"@effected/toml": "^0.16.0",
-		"@effected/yaml": "^0.24.0",
+		"@effected/yaml": "^0.25.0",
 		"effect": "^4.0.0"
 	},
 	"peerDependenciesMeta": {