@jfdevelops/react-layout 0.21.0 → 0.22.2

package/dist/errors/invalid-path.d.cts

@@ -1,14 +1,106 @@
-import { CreatedReactLayoutError, ReactLayoutErrorContext } from "./react-layout-error.cjs";
+import { ImplementedErrorClass } from "../node_modules/.pnpm/@jfdevelops_create-error@0.2.0_patch_hash_afc71b16c3f866f54416d30f467784ddc31736feb04f281a5fc4772ea422f4a9/node_modules/@jfdevelops/create-error/dist/types.cjs";
 
 //#region src/errors/invalid-path.d.ts
-declare const scope: "path";
-/** Context describing a path that is unavailable to React Layout. */
-interface InvalidPathContext extends ReactLayoutErrorContext<typeof scope> {
+declare const context: import("arktype/internal/variants/object.ts").ObjectType<{
   path: unknown;
-  validPaths?: readonly string[];
-  reason?: string;
-}
-declare const InvalidPathError_base: CreatedReactLayoutError<"invalidPath", "path", InvalidPathContext>;
+  scope: "path";
+  reason?: string | undefined;
+  validPaths?: string[] | undefined;
+}, {}>;
+type InvalidPathContext = typeof context.infer;
+declare const InvalidPathError_base: ImplementedErrorClass<{
+  definition: import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>;
+} & {
+  data: {
+    readonly property: "context";
+    readonly resolve: ({
+      definition,
+      input
+    }: import("@jfdevelops/create-error/types").ResolveContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>) => {
+      scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    };
+  };
+  message: ({
+    definition,
+    data,
+    implementation
+  }: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>>) => string & import("@jfdevelops/create-error/types").TypeSlot<"implementationArgument", {
+    readonly context: import("@jfdevelops/create-error/types").DataSlot;
+    readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+  }>;
+} & {
+  properties(context: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>>): {
+    readonly code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+    readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    readonly renderMessage: (renderer?: (scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">, context: import("@jfdevelops/create-error/types").DataSlot) => string) => string;
+  };
+} & {
+  toJSON(error: import("@jfdevelops/create-error/types").BlueprintErrorTemplate<NoInfer<{
+    data: {
+      readonly property: "context";
+      readonly resolve: ({
+        definition,
+        input
+      }: import("@jfdevelops/create-error/types").ResolveContext<import("arktype/internal/variants/object.ts").ObjectType<{
+        code: string;
+        scope: string;
+      }, {}>>) => {
+        scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+      };
+    };
+    message: ({
+      definition,
+      data,
+      implementation
+    }: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>) => string & import("@jfdevelops/create-error/types").TypeSlot<"implementationArgument", {
+      readonly context: import("@jfdevelops/create-error/types").DataSlot;
+      readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    }>;
+  } & {
+    properties(context: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>): {
+      readonly code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+      readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+      readonly renderMessage: (renderer?: (scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">, context: import("@jfdevelops/create-error/types").DataSlot) => string) => string;
+    };
+  }>>): {
+    name: string;
+    code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+    scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    message: string;
+    context: unknown;
+  };
+}, {
+  readonly code: string;
+  readonly scope: string;
+}, {
+  path: unknown;
+  scope: "path";
+  reason?: string | undefined;
+  validPaths?: string[] | undefined;
+}, {
+  path: unknown;
+  scope: "path";
+  reason?: string | undefined;
+  validPaths?: string[] | undefined;
+}>;
 /** Thrown when a requested layout path is invalid or unavailable. */
 declare class InvalidPathError extends InvalidPathError_base {}
 //#endregion

package/dist/errors/invalid-path.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"invalid-path.d.cts","names":[],"sources":["../../src/errors/invalid-path.ts"],"mappings":";;;cAKM,KAAA;;UAGW,kBAAA,SACP,uBAAuB,QAAQ,KAAA;EACvC,IAAA;EACA,UAAA;EACA,MAAA;AAAA;AAAA,cACD,qBAAA;;cAGY,gBAAA,SAAyB,qBAcpC"}
+{"version":3,"file":"invalid-path.d.cts","names":[],"sources":["../../src/errors/invalid-path.ts"],"mappings":";;;cAGM,OAAA,gDAAO,UAAA;;;;;;KAOD,kBAAA,UAA4B,OAAA,CAAQ,KAAK;AAAA,cAAC,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGzC,gBAAA,SAAyB,qBAkBlC"}

package/dist/errors/invalid-path.d.mts

@@ -1,14 +1,106 @@
-import { CreatedReactLayoutError, ReactLayoutErrorContext } from "./react-layout-error.mjs";
+import { ImplementedErrorClass } from "../node_modules/.pnpm/@jfdevelops_create-error@0.2.0_patch_hash_afc71b16c3f866f54416d30f467784ddc31736feb04f281a5fc4772ea422f4a9/node_modules/@jfdevelops/create-error/dist/types.mjs";
 
 //#region src/errors/invalid-path.d.ts
-declare const scope: "path";
-/** Context describing a path that is unavailable to React Layout. */
-interface InvalidPathContext extends ReactLayoutErrorContext<typeof scope> {
+declare const context: import("arktype/internal/variants/object.ts").ObjectType<{
   path: unknown;
-  validPaths?: readonly string[];
-  reason?: string;
-}
-declare const InvalidPathError_base: CreatedReactLayoutError<"invalidPath", "path", InvalidPathContext>;
+  scope: "path";
+  reason?: string | undefined;
+  validPaths?: string[] | undefined;
+}, {}>;
+type InvalidPathContext = typeof context.infer;
+declare const InvalidPathError_base: ImplementedErrorClass<{
+  definition: import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>;
+} & {
+  data: {
+    readonly property: "context";
+    readonly resolve: ({
+      definition,
+      input
+    }: import("@jfdevelops/create-error/types").ResolveContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>) => {
+      scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    };
+  };
+  message: ({
+    definition,
+    data,
+    implementation
+  }: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>>) => string & import("@jfdevelops/create-error/types").TypeSlot<"implementationArgument", {
+    readonly context: import("@jfdevelops/create-error/types").DataSlot;
+    readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+  }>;
+} & {
+  properties(context: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>>): {
+    readonly code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+    readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    readonly renderMessage: (renderer?: (scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">, context: import("@jfdevelops/create-error/types").DataSlot) => string) => string;
+  };
+} & {
+  toJSON(error: import("@jfdevelops/create-error/types").BlueprintErrorTemplate<NoInfer<{
+    data: {
+      readonly property: "context";
+      readonly resolve: ({
+        definition,
+        input
+      }: import("@jfdevelops/create-error/types").ResolveContext<import("arktype/internal/variants/object.ts").ObjectType<{
+        code: string;
+        scope: string;
+      }, {}>>) => {
+        scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+      };
+    };
+    message: ({
+      definition,
+      data,
+      implementation
+    }: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>) => string & import("@jfdevelops/create-error/types").TypeSlot<"implementationArgument", {
+      readonly context: import("@jfdevelops/create-error/types").DataSlot;
+      readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    }>;
+  } & {
+    properties(context: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>): {
+      readonly code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+      readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+      readonly renderMessage: (renderer?: (scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">, context: import("@jfdevelops/create-error/types").DataSlot) => string) => string;
+    };
+  }>>): {
+    name: string;
+    code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+    scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    message: string;
+    context: unknown;
+  };
+}, {
+  readonly code: string;
+  readonly scope: string;
+}, {
+  path: unknown;
+  scope: "path";
+  reason?: string | undefined;
+  validPaths?: string[] | undefined;
+}, {
+  path: unknown;
+  scope: "path";
+  reason?: string | undefined;
+  validPaths?: string[] | undefined;
+}>;
 /** Thrown when a requested layout path is invalid or unavailable. */
 declare class InvalidPathError extends InvalidPathError_base {}
 //#endregion

package/dist/errors/invalid-path.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"invalid-path.d.mts","names":[],"sources":["../../src/errors/invalid-path.ts"],"mappings":";;;cAKM,KAAA;;UAGW,kBAAA,SACP,uBAAuB,QAAQ,KAAA;EACvC,IAAA;EACA,UAAA;EACA,MAAA;AAAA;AAAA,cACD,qBAAA;;cAGY,gBAAA,SAAyB,qBAcpC"}
+{"version":3,"file":"invalid-path.d.mts","names":[],"sources":["../../src/errors/invalid-path.ts"],"mappings":";;;cAGM,OAAA,gDAAO,UAAA;;;;;;KAOD,kBAAA,UAA4B,OAAA,CAAQ,KAAK;AAAA,cAAC,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGzC,gBAAA,SAAyB,qBAkBlC"}

package/dist/errors/invalid-path.mjs

@@ -1,16 +1,22 @@
 import { createReactLayoutError } from "./react-layout-error.mjs";
+import { type } from "arktype";
 
 //#region src/errors/invalid-path.ts
-const scope = "path";
+const context = type({
+	path: "unknown",
+	"reason?": "string",
+	scope: "'path'",
+	"validPaths?": "string[]"
+});
 /** Thrown when a requested layout path is invalid or unavailable. */
 var InvalidPathError = class extends createReactLayoutError({
 	code: "invalidPath",
-	scope
-})((scope, { path, validPaths, reason }) => {
-	return `[${scope}]: Path ${JSON.stringify(path) ?? `"${String(path)}"`} is not available.${reason ? ` ${reason}` : ""}${validPaths && validPaths.length > 0 ? ` Available paths are ${new Intl.ListFormat("en", {
+	scope: "path"
+}).defineContext(context).implement(({ context, scope }) => {
+	return `[${scope}]: Path ${JSON.stringify(context.path) ?? `"${String(context.path)}"`} is not available.${context.reason ? ` ${context.reason}` : ""}${context.validPaths && context.validPaths.length > 0 ? ` Available paths are ${new Intl.ListFormat("en", {
 		style: "long",
 		type: "disjunction"
-	}).format(validPaths)}.` : ""}`;
+	}).format(context.validPaths)}.` : ""}`;
 }) {};
 
 //#endregion

package/dist/errors/invalid-path.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"invalid-path.mjs","names":[],"sources":["../../src/errors/invalid-path.ts"],"sourcesContent":["import {\n  createReactLayoutError,\n  type ReactLayoutErrorContext,\n} from './react-layout-error';\n\nconst scope = 'path' as const;\n\n/** Context describing a path that is unavailable to React Layout. */\nexport interface InvalidPathContext\n  extends ReactLayoutErrorContext<typeof scope> {\n  path: unknown;\n  validPaths?: readonly string[];\n  reason?: string;\n}\n\n/** Thrown when a requested layout path is invalid or unavailable. */\nexport class InvalidPathError extends createReactLayoutError(\n  { code: 'invalidPath', scope },\n)((scope, { path, validPaths, reason }: InvalidPathContext) => {\n  const quotedPath = JSON.stringify(path) ?? `\"${String(path)}\"`;\n  const reasonMessage = reason ? ` ${reason}` : '';\n  const validPathsMessage =\n    validPaths && validPaths.length > 0\n      ? ` Available paths are ${new Intl.ListFormat('en', {\n          style: 'long',\n          type: 'disjunction',\n        }).format(validPaths)}.`\n      : '';\n\n  return `[${scope}]: Path ${quotedPath} is not available.${reasonMessage}${validPathsMessage}`;\n}) {}\n"],"mappings":";;;AAKA,MAAM,QAAQ;;AAWd,IAAa,mBAAb,cAAsC,uBACpC;CAAE,MAAM;CAAe;AAAM,CAC/B,GAAG,OAAO,EAAE,MAAM,YAAY,aAAiC;CAW7D,OAAO,IAAI,MAAM,UAVE,KAAK,UAAU,IAAI,KAAK,IAAI,OAAO,IAAI,EAAE,GAUtB,oBAThB,SAAS,IAAI,WAAW,KAE5C,cAAc,WAAW,SAAS,IAC9B,wBAAwB,IAAI,KAAK,WAAW,MAAM;EAChD,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,UAAU,EAAE,KACtB;AAGR,CAAC,EAAE,CAAC"}
+{"version":3,"file":"invalid-path.mjs","names":[],"sources":["../../src/errors/invalid-path.ts"],"sourcesContent":["import { type } from 'arktype';\nimport { createReactLayoutError } from './react-layout-error';\n\nconst context = type({\n  path: 'unknown',\n  'reason?': 'string',\n  scope: \"'path'\",\n  'validPaths?': 'string[]',\n});\n\nexport type InvalidPathContext = typeof context.infer;\n\n/** Thrown when a requested layout path is invalid or unavailable. */\nexport class InvalidPathError extends createReactLayoutError({\n  code: 'invalidPath',\n  scope: 'path',\n})\n  .defineContext(context)\n  .implement(({ context, scope }) => {\n    const quotedPath =\n      JSON.stringify(context.path) ?? `\"${String(context.path)}\"`;\n    const reasonMessage = context.reason ? ` ${context.reason}` : '';\n    const validPathsMessage =\n      context.validPaths && context.validPaths.length > 0\n        ? ` Available paths are ${new Intl.ListFormat('en', {\n            style: 'long',\n            type: 'disjunction',\n          }).format(context.validPaths)}.`\n        : '';\n\n    return `[${scope}]: Path ${quotedPath} is not available.${reasonMessage}${validPathsMessage}`;\n  }) {}\n"],"mappings":";;;;AAGA,MAAM,UAAU,KAAK;CACnB,MAAM;CACN,WAAW;CACX,OAAO;CACP,eAAe;AACjB,CAAC;;AAKD,IAAa,mBAAb,cAAsC,uBAAuB;CAC3D,MAAM;CACN,OAAO;AACT,CAAC,EACE,cAAc,OAAO,EACrB,WAAW,EAAE,SAAS,YAAY;CAYjC,OAAO,IAAI,MAAM,UAVf,KAAK,UAAU,QAAQ,IAAI,KAAK,IAAI,OAAO,QAAQ,IAAI,EAAE,GAUrB,oBAThB,QAAQ,SAAS,IAAI,QAAQ,WAAW,KAE5D,QAAQ,cAAc,QAAQ,WAAW,SAAS,IAC9C,wBAAwB,IAAI,KAAK,WAAW,MAAM;EAChD,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,QAAQ,UAAU,EAAE,KAC9B;AAGR,CAAC,EAAE,CAAC"}

package/dist/errors/invalid-resource.cjs

@@ -1,16 +1,22 @@
 const require_react_layout_error = require('./react-layout-error.cjs');
+let arktype = require("arktype");
 
 //#region src/errors/invalid-resource.ts
-const scope = "resource";
+const context = (0, arktype.type)({
+	"reason?": "string",
+	resource: "unknown",
+	scope: "'resource'",
+	"validResources?": "string[]"
+});
 /** Thrown when a requested layout resource is invalid or unavailable. */
 var InvalidResourceError = class extends require_react_layout_error.createReactLayoutError({
 	code: "invalidResource",
-	scope
-})((scope, { resource, validResources, reason }) => {
-	return `[${scope}]: Resource ${JSON.stringify(resource) ?? `"${String(resource)}"`} is not available.${reason ? ` ${reason}` : ""}${validResources && validResources.length > 0 ? ` Available resources are ${new Intl.ListFormat("en", {
+	scope: "resource"
+}).defineContext(context).implement(({ context, scope }) => {
+	return `[${scope}]: Resource ${JSON.stringify(context.resource) ?? `"${String(context.resource)}"`} is not available.${context.reason ? ` ${context.reason}` : ""}${context.validResources && context.validResources.length > 0 ? ` Available resources are ${new Intl.ListFormat("en", {
 		style: "long",
 		type: "disjunction"
-	}).format(validResources)}.` : ""}`;
+	}).format(context.validResources)}.` : ""}`;
 }) {};
 
 //#endregion

package/dist/errors/invalid-resource.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"invalid-resource.cjs","names":["createReactLayoutError"],"sources":["../../src/errors/invalid-resource.ts"],"sourcesContent":["import {\n  createReactLayoutError,\n  type ReactLayoutErrorContext,\n} from './react-layout-error';\n\nconst scope = 'resource' as const;\n\n/** Context describing a resource that is unavailable to React Layout. */\nexport interface InvalidResourceContext\n  extends ReactLayoutErrorContext<typeof scope> {\n  resource: unknown;\n  validResources?: readonly string[];\n  reason?: string;\n}\n\n/** Thrown when a requested layout resource is invalid or unavailable. */\nexport class InvalidResourceError extends createReactLayoutError(\n  { code: 'invalidResource', scope },\n)((scope, { resource, validResources, reason }: InvalidResourceContext) => {\n  const quotedResource = JSON.stringify(resource) ?? `\"${String(resource)}\"`;\n  const reasonMessage = reason ? ` ${reason}` : '';\n  const validResourcesMessage =\n    validResources && validResources.length > 0\n      ? ` Available resources are ${new Intl.ListFormat('en', {\n          style: 'long',\n          type: 'disjunction',\n        }).format(validResources)}.`\n      : '';\n\n  return `[${scope}]: Resource ${quotedResource} is not available.${reasonMessage}${validResourcesMessage}`;\n}) {}\n"],"mappings":";;;AAKA,MAAM,QAAQ;;AAWd,IAAa,uBAAb,cAA0CA,kDACxC;CAAE,MAAM;CAAmB;AAAM,CACnC,GAAG,OAAO,EAAE,UAAU,gBAAgB,aAAqC;CAWzE,OAAO,IAAI,MAAM,cAVM,KAAK,UAAU,QAAQ,KAAK,IAAI,OAAO,QAAQ,EAAE,GAU1B,oBATxB,SAAS,IAAI,WAAW,KAE5C,kBAAkB,eAAe,SAAS,IACtC,4BAA4B,IAAI,KAAK,WAAW,MAAM;EACpD,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,cAAc,EAAE,KAC1B;AAGR,CAAC,EAAE,CAAC"}
+{"version":3,"file":"invalid-resource.cjs","names":["createReactLayoutError"],"sources":["../../src/errors/invalid-resource.ts"],"sourcesContent":["import { type } from 'arktype';\nimport { createReactLayoutError } from './react-layout-error';\n\nconst context = type({\n  'reason?': 'string',\n  resource: 'unknown',\n  scope: \"'resource'\",\n  'validResources?': 'string[]',\n});\n\nexport type InvalidResourceContext = typeof context.infer;\n\n/** Thrown when a requested layout resource is invalid or unavailable. */\nexport class InvalidResourceError extends createReactLayoutError({\n  code: 'invalidResource',\n  scope: 'resource',\n})\n  .defineContext(context)\n  .implement(({ context, scope }) => {\n    const quotedResource =\n      JSON.stringify(context.resource) ?? `\"${String(context.resource)}\"`;\n    const reasonMessage = context.reason ? ` ${context.reason}` : '';\n    const validResourcesMessage =\n      context.validResources && context.validResources.length > 0\n        ? ` Available resources are ${new Intl.ListFormat('en', {\n            style: 'long',\n            type: 'disjunction',\n          }).format(context.validResources)}.`\n        : '';\n\n    return `[${scope}]: Resource ${quotedResource} is not available.${reasonMessage}${validResourcesMessage}`;\n  }) {}\n"],"mappings":";;;;AAGA,MAAM,4BAAe;CACnB,WAAW;CACX,UAAU;CACV,OAAO;CACP,mBAAmB;AACrB,CAAC;;AAKD,IAAa,uBAAb,cAA0CA,kDAAuB;CAC/D,MAAM;CACN,OAAO;AACT,CAAC,EACE,cAAc,OAAO,EACrB,WAAW,EAAE,SAAS,YAAY;CAYjC,OAAO,IAAI,MAAM,cAVf,KAAK,UAAU,QAAQ,QAAQ,KAAK,IAAI,OAAO,QAAQ,QAAQ,EAAE,GAUrB,oBATxB,QAAQ,SAAS,IAAI,QAAQ,WAAW,KAE5D,QAAQ,kBAAkB,QAAQ,eAAe,SAAS,IACtD,4BAA4B,IAAI,KAAK,WAAW,MAAM;EACpD,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,QAAQ,cAAc,EAAE,KAClC;AAGR,CAAC,EAAE,CAAC"}

package/dist/errors/invalid-resource.d.cts

@@ -1,14 +1,106 @@
-import { CreatedReactLayoutError, ReactLayoutErrorContext } from "./react-layout-error.cjs";
+import { ImplementedErrorClass } from "../node_modules/.pnpm/@jfdevelops_create-error@0.2.0_patch_hash_afc71b16c3f866f54416d30f467784ddc31736feb04f281a5fc4772ea422f4a9/node_modules/@jfdevelops/create-error/dist/types.cjs";
 
 //#region src/errors/invalid-resource.d.ts
-declare const scope: "resource";
-/** Context describing a resource that is unavailable to React Layout. */
-interface InvalidResourceContext extends ReactLayoutErrorContext<typeof scope> {
+declare const context: import("arktype/internal/variants/object.ts").ObjectType<{
   resource: unknown;
-  validResources?: readonly string[];
-  reason?: string;
-}
-declare const InvalidResourceError_base: CreatedReactLayoutError<"invalidResource", "resource", InvalidResourceContext>;
+  scope: "resource";
+  reason?: string | undefined;
+  validResources?: string[] | undefined;
+}, {}>;
+type InvalidResourceContext = typeof context.infer;
+declare const InvalidResourceError_base: ImplementedErrorClass<{
+  definition: import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>;
+} & {
+  data: {
+    readonly property: "context";
+    readonly resolve: ({
+      definition,
+      input
+    }: import("@jfdevelops/create-error/types").ResolveContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>) => {
+      scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    };
+  };
+  message: ({
+    definition,
+    data,
+    implementation
+  }: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>>) => string & import("@jfdevelops/create-error/types").TypeSlot<"implementationArgument", {
+    readonly context: import("@jfdevelops/create-error/types").DataSlot;
+    readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+  }>;
+} & {
+  properties(context: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>>): {
+    readonly code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+    readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    readonly renderMessage: (renderer?: (scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">, context: import("@jfdevelops/create-error/types").DataSlot) => string) => string;
+  };
+} & {
+  toJSON(error: import("@jfdevelops/create-error/types").BlueprintErrorTemplate<NoInfer<{
+    data: {
+      readonly property: "context";
+      readonly resolve: ({
+        definition,
+        input
+      }: import("@jfdevelops/create-error/types").ResolveContext<import("arktype/internal/variants/object.ts").ObjectType<{
+        code: string;
+        scope: string;
+      }, {}>>) => {
+        scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+      };
+    };
+    message: ({
+      definition,
+      data,
+      implementation
+    }: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>) => string & import("@jfdevelops/create-error/types").TypeSlot<"implementationArgument", {
+      readonly context: import("@jfdevelops/create-error/types").DataSlot;
+      readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    }>;
+  } & {
+    properties(context: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>): {
+      readonly code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+      readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+      readonly renderMessage: (renderer?: (scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">, context: import("@jfdevelops/create-error/types").DataSlot) => string) => string;
+    };
+  }>>): {
+    name: string;
+    code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+    scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    message: string;
+    context: unknown;
+  };
+}, {
+  readonly code: string;
+  readonly scope: string;
+}, {
+  resource: unknown;
+  scope: "resource";
+  reason?: string | undefined;
+  validResources?: string[] | undefined;
+}, {
+  resource: unknown;
+  scope: "resource";
+  reason?: string | undefined;
+  validResources?: string[] | undefined;
+}>;
 /** Thrown when a requested layout resource is invalid or unavailable. */
 declare class InvalidResourceError extends InvalidResourceError_base {}
 //#endregion

package/dist/errors/invalid-resource.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"invalid-resource.d.cts","names":[],"sources":["../../src/errors/invalid-resource.ts"],"mappings":";;;cAKM,KAAA;;UAGW,sBAAA,SACP,uBAAuB,QAAQ,KAAA;EACvC,QAAA;EACA,cAAA;EACA,MAAA;AAAA;AAAA,cACD,yBAAA;;cAGY,oBAAA,SAA6B,yBAcxC"}
+{"version":3,"file":"invalid-resource.d.cts","names":[],"sources":["../../src/errors/invalid-resource.ts"],"mappings":";;;cAGM,OAAA,gDAAO,UAAA;;;;;;KAOD,sBAAA,UAAgC,OAAA,CAAQ,KAAK;AAAA,cAAC,yBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAG7C,oBAAA,SAA6B,yBAkBtC"}

package/dist/errors/invalid-resource.d.mts

@@ -1,14 +1,106 @@
-import { CreatedReactLayoutError, ReactLayoutErrorContext } from "./react-layout-error.mjs";
+import { ImplementedErrorClass } from "../node_modules/.pnpm/@jfdevelops_create-error@0.2.0_patch_hash_afc71b16c3f866f54416d30f467784ddc31736feb04f281a5fc4772ea422f4a9/node_modules/@jfdevelops/create-error/dist/types.mjs";
 
 //#region src/errors/invalid-resource.d.ts
-declare const scope: "resource";
-/** Context describing a resource that is unavailable to React Layout. */
-interface InvalidResourceContext extends ReactLayoutErrorContext<typeof scope> {
+declare const context: import("arktype/internal/variants/object.ts").ObjectType<{
   resource: unknown;
-  validResources?: readonly string[];
-  reason?: string;
-}
-declare const InvalidResourceError_base: CreatedReactLayoutError<"invalidResource", "resource", InvalidResourceContext>;
+  scope: "resource";
+  reason?: string | undefined;
+  validResources?: string[] | undefined;
+}, {}>;
+type InvalidResourceContext = typeof context.infer;
+declare const InvalidResourceError_base: ImplementedErrorClass<{
+  definition: import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>;
+} & {
+  data: {
+    readonly property: "context";
+    readonly resolve: ({
+      definition,
+      input
+    }: import("@jfdevelops/create-error/types").ResolveContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>) => {
+      scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    };
+  };
+  message: ({
+    definition,
+    data,
+    implementation
+  }: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>>) => string & import("@jfdevelops/create-error/types").TypeSlot<"implementationArgument", {
+    readonly context: import("@jfdevelops/create-error/types").DataSlot;
+    readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+  }>;
+} & {
+  properties(context: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    scope: string;
+  }, {}>>): {
+    readonly code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+    readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    readonly renderMessage: (renderer?: (scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">, context: import("@jfdevelops/create-error/types").DataSlot) => string) => string;
+  };
+} & {
+  toJSON(error: import("@jfdevelops/create-error/types").BlueprintErrorTemplate<NoInfer<{
+    data: {
+      readonly property: "context";
+      readonly resolve: ({
+        definition,
+        input
+      }: import("@jfdevelops/create-error/types").ResolveContext<import("arktype/internal/variants/object.ts").ObjectType<{
+        code: string;
+        scope: string;
+      }, {}>>) => {
+        scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+      };
+    };
+    message: ({
+      definition,
+      data,
+      implementation
+    }: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>) => string & import("@jfdevelops/create-error/types").TypeSlot<"implementationArgument", {
+      readonly context: import("@jfdevelops/create-error/types").DataSlot;
+      readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    }>;
+  } & {
+    properties(context: import("@jfdevelops/create-error/types").BlueprintContext<import("arktype/internal/variants/object.ts").ObjectType<{
+      code: string;
+      scope: string;
+    }, {}>>): {
+      readonly code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+      readonly scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+      readonly renderMessage: (renderer?: (scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">, context: import("@jfdevelops/create-error/types").DataSlot) => string) => string;
+    };
+  }>>): {
+    name: string;
+    code: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "code">;
+    scope: string & import("@jfdevelops/create-error/types").TypeSlot<"definition", "scope">;
+    message: string;
+    context: unknown;
+  };
+}, {
+  readonly code: string;
+  readonly scope: string;
+}, {
+  resource: unknown;
+  scope: "resource";
+  reason?: string | undefined;
+  validResources?: string[] | undefined;
+}, {
+  resource: unknown;
+  scope: "resource";
+  reason?: string | undefined;
+  validResources?: string[] | undefined;
+}>;
 /** Thrown when a requested layout resource is invalid or unavailable. */
 declare class InvalidResourceError extends InvalidResourceError_base {}
 //#endregion

package/dist/errors/invalid-resource.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"invalid-resource.d.mts","names":[],"sources":["../../src/errors/invalid-resource.ts"],"mappings":";;;cAKM,KAAA;;UAGW,sBAAA,SACP,uBAAuB,QAAQ,KAAA;EACvC,QAAA;EACA,cAAA;EACA,MAAA;AAAA;AAAA,cACD,yBAAA;;cAGY,oBAAA,SAA6B,yBAcxC"}
+{"version":3,"file":"invalid-resource.d.mts","names":[],"sources":["../../src/errors/invalid-resource.ts"],"mappings":";;;cAGM,OAAA,gDAAO,UAAA;;;;;;KAOD,sBAAA,UAAgC,OAAA,CAAQ,KAAK;AAAA,cAAC,yBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAG7C,oBAAA,SAA6B,yBAkBtC"}

package/dist/errors/invalid-resource.mjs

@@ -1,16 +1,22 @@
 import { createReactLayoutError } from "./react-layout-error.mjs";
+import { type } from "arktype";
 
 //#region src/errors/invalid-resource.ts
-const scope = "resource";
+const context = type({
+	"reason?": "string",
+	resource: "unknown",
+	scope: "'resource'",
+	"validResources?": "string[]"
+});
 /** Thrown when a requested layout resource is invalid or unavailable. */
 var InvalidResourceError = class extends createReactLayoutError({
 	code: "invalidResource",
-	scope
-})((scope, { resource, validResources, reason }) => {
-	return `[${scope}]: Resource ${JSON.stringify(resource) ?? `"${String(resource)}"`} is not available.${reason ? ` ${reason}` : ""}${validResources && validResources.length > 0 ? ` Available resources are ${new Intl.ListFormat("en", {
+	scope: "resource"
+}).defineContext(context).implement(({ context, scope }) => {
+	return `[${scope}]: Resource ${JSON.stringify(context.resource) ?? `"${String(context.resource)}"`} is not available.${context.reason ? ` ${context.reason}` : ""}${context.validResources && context.validResources.length > 0 ? ` Available resources are ${new Intl.ListFormat("en", {
 		style: "long",
 		type: "disjunction"
-	}).format(validResources)}.` : ""}`;
+	}).format(context.validResources)}.` : ""}`;
 }) {};
 
 //#endregion

package/dist/errors/invalid-resource.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"invalid-resource.mjs","names":[],"sources":["../../src/errors/invalid-resource.ts"],"sourcesContent":["import {\n  createReactLayoutError,\n  type ReactLayoutErrorContext,\n} from './react-layout-error';\n\nconst scope = 'resource' as const;\n\n/** Context describing a resource that is unavailable to React Layout. */\nexport interface InvalidResourceContext\n  extends ReactLayoutErrorContext<typeof scope> {\n  resource: unknown;\n  validResources?: readonly string[];\n  reason?: string;\n}\n\n/** Thrown when a requested layout resource is invalid or unavailable. */\nexport class InvalidResourceError extends createReactLayoutError(\n  { code: 'invalidResource', scope },\n)((scope, { resource, validResources, reason }: InvalidResourceContext) => {\n  const quotedResource = JSON.stringify(resource) ?? `\"${String(resource)}\"`;\n  const reasonMessage = reason ? ` ${reason}` : '';\n  const validResourcesMessage =\n    validResources && validResources.length > 0\n      ? ` Available resources are ${new Intl.ListFormat('en', {\n          style: 'long',\n          type: 'disjunction',\n        }).format(validResources)}.`\n      : '';\n\n  return `[${scope}]: Resource ${quotedResource} is not available.${reasonMessage}${validResourcesMessage}`;\n}) {}\n"],"mappings":";;;AAKA,MAAM,QAAQ;;AAWd,IAAa,uBAAb,cAA0C,uBACxC;CAAE,MAAM;CAAmB;AAAM,CACnC,GAAG,OAAO,EAAE,UAAU,gBAAgB,aAAqC;CAWzE,OAAO,IAAI,MAAM,cAVM,KAAK,UAAU,QAAQ,KAAK,IAAI,OAAO,QAAQ,EAAE,GAU1B,oBATxB,SAAS,IAAI,WAAW,KAE5C,kBAAkB,eAAe,SAAS,IACtC,4BAA4B,IAAI,KAAK,WAAW,MAAM;EACpD,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,cAAc,EAAE,KAC1B;AAGR,CAAC,EAAE,CAAC"}
+{"version":3,"file":"invalid-resource.mjs","names":[],"sources":["../../src/errors/invalid-resource.ts"],"sourcesContent":["import { type } from 'arktype';\nimport { createReactLayoutError } from './react-layout-error';\n\nconst context = type({\n  'reason?': 'string',\n  resource: 'unknown',\n  scope: \"'resource'\",\n  'validResources?': 'string[]',\n});\n\nexport type InvalidResourceContext = typeof context.infer;\n\n/** Thrown when a requested layout resource is invalid or unavailable. */\nexport class InvalidResourceError extends createReactLayoutError({\n  code: 'invalidResource',\n  scope: 'resource',\n})\n  .defineContext(context)\n  .implement(({ context, scope }) => {\n    const quotedResource =\n      JSON.stringify(context.resource) ?? `\"${String(context.resource)}\"`;\n    const reasonMessage = context.reason ? ` ${context.reason}` : '';\n    const validResourcesMessage =\n      context.validResources && context.validResources.length > 0\n        ? ` Available resources are ${new Intl.ListFormat('en', {\n            style: 'long',\n            type: 'disjunction',\n          }).format(context.validResources)}.`\n        : '';\n\n    return `[${scope}]: Resource ${quotedResource} is not available.${reasonMessage}${validResourcesMessage}`;\n  }) {}\n"],"mappings":";;;;AAGA,MAAM,UAAU,KAAK;CACnB,WAAW;CACX,UAAU;CACV,OAAO;CACP,mBAAmB;AACrB,CAAC;;AAKD,IAAa,uBAAb,cAA0C,uBAAuB;CAC/D,MAAM;CACN,OAAO;AACT,CAAC,EACE,cAAc,OAAO,EACrB,WAAW,EAAE,SAAS,YAAY;CAYjC,OAAO,IAAI,MAAM,cAVf,KAAK,UAAU,QAAQ,QAAQ,KAAK,IAAI,OAAO,QAAQ,QAAQ,EAAE,GAUrB,oBATxB,QAAQ,SAAS,IAAI,QAAQ,WAAW,KAE5D,QAAQ,kBAAkB,QAAQ,eAAe,SAAS,IACtD,4BAA4B,IAAI,KAAK,WAAW,MAAM;EACpD,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,QAAQ,cAAc,EAAE,KAClC;AAGR,CAAC,EAAE,CAAC"}