@jfdevelops/react-layout 0.22.0 → 0.22.2

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

@@ -1 +1 @@
-{"version":3,"file":"invalid-component.d.cts","names":[],"sources":["../../src/errors/invalid-component.ts"],"mappings":";;;cAKM,KAAA;;UAGW,uBAAA,SACP,uBAAuB,QAAQ,KAAA;EACvC,SAAA;EACA,IAAA;EACA,QAAA;EACA,eAAA;EACA,MAAA;AAAA;AAAA,cACD,0BAAA;;cAGY,qBAAA,SAA8B,0BAkC1C"}
+{"version":3,"file":"invalid-component.d.cts","names":[],"sources":["../../src/errors/invalid-component.ts"],"mappings":";;;cAGM,OAAA,gDAAO,UAAA;;;;;;;;KASD,uBAAA,UAAiC,OAAA,CAAQ,KAAK;AAAA,cAAC,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAG9C,qBAAA,SAA8B,0BA0BvC"}

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

@@ -1,16 +1,112 @@
-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-component.d.ts
-declare const scope: "component";
-/** Context describing an invalid or unconfigured component slot. */
-interface InvalidComponentContext extends ReactLayoutErrorContext<typeof scope> {
+declare const context: import("arktype/internal/variants/object.ts").ObjectType<{
   component: unknown;
-  path?: string;
-  resource?: string;
-  validComponents?: readonly string[];
-  reason?: string;
-}
-declare const InvalidComponentError_base: CreatedReactLayoutError<"invalidComponent", "component", InvalidComponentContext>;
+  scope: "component";
+  path?: string | undefined;
+  reason?: string | undefined;
+  resource?: string | undefined;
+  validComponents?: string[] | undefined;
+}, {}>;
+type InvalidComponentContext = typeof context.infer;
+declare const InvalidComponentError_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;
+}, {
+  component: unknown;
+  scope: "component";
+  path?: string | undefined;
+  reason?: string | undefined;
+  resource?: string | undefined;
+  validComponents?: string[] | undefined;
+}, {
+  component: unknown;
+  scope: "component";
+  path?: string | undefined;
+  reason?: string | undefined;
+  resource?: string | undefined;
+  validComponents?: string[] | undefined;
+}>;
 /** Thrown when a requested component slot cannot be resolved. */
 declare class InvalidComponentError extends InvalidComponentError_base {}
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"invalid-component.d.mts","names":[],"sources":["../../src/errors/invalid-component.ts"],"mappings":";;;cAKM,KAAA;;UAGW,uBAAA,SACP,uBAAuB,QAAQ,KAAA;EACvC,SAAA;EACA,IAAA;EACA,QAAA;EACA,eAAA;EACA,MAAA;AAAA;AAAA,cACD,0BAAA;;cAGY,qBAAA,SAA8B,0BAkC1C"}
+{"version":3,"file":"invalid-component.d.mts","names":[],"sources":["../../src/errors/invalid-component.ts"],"mappings":";;;cAGM,OAAA,gDAAO,UAAA;;;;;;;;KASD,uBAAA,UAAiC,OAAA,CAAQ,KAAK;AAAA,cAAC,0BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAG9C,qBAAA,SAA8B,0BA0BvC"}

package/dist/errors/invalid-component.mjs

@@ -1,19 +1,27 @@
 import { createReactLayoutError } from "./react-layout-error.mjs";
+import { type } from "arktype";
 
 //#region src/errors/invalid-component.ts
-const scope = "component";
+const context = type({
+	component: "unknown",
+	"path?": "string",
+	"reason?": "string",
+	"resource?": "string",
+	scope: "'component'",
+	"validComponents?": "string[]"
+});
 /** Thrown when a requested component slot cannot be resolved. */
 var InvalidComponentError = class extends createReactLayoutError({
 	code: "invalidComponent",
-	scope
-})((scope, { component, path, resource, validComponents, reason }) => {
-	const quotedComponent = JSON.stringify(component) ?? `"${String(component)}"`;
-	const locationParts = [path ? `path "${path}"` : void 0, resource ? `resource "${resource}"` : void 0].filter((part) => part !== void 0);
+	scope: "component"
+}).defineContext(context).implement(({ context, scope }) => {
+	const quotedComponent = JSON.stringify(context.component) ?? `"${String(context.component)}"`;
+	const locationParts = [context.path ? `path "${context.path}"` : void 0, context.resource ? `resource "${context.resource}"` : void 0].filter((part) => part !== void 0);
 	const locationMessage = locationParts.length > 0 ? ` for ${locationParts.join(" and ")}` : "";
-	return `[${scope}]: ${reason ?? `Component slot ${quotedComponent}${locationMessage} is not configured.`}${validComponents && validComponents.length > 0 ? ` Available component slots are ${new Intl.ListFormat("en", {
+	return `[${scope}]: ${context.reason ?? `Component slot ${quotedComponent}${locationMessage} is not configured.`}${context.validComponents && context.validComponents.length > 0 ? ` Available component slots are ${new Intl.ListFormat("en", {
 		style: "long",
 		type: "disjunction"
-	}).format(validComponents)}.` : ""}`;
+	}).format(context.validComponents)}.` : ""}`;
 }) {};
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"invalid-component.mjs","names":[],"sources":["../../src/errors/invalid-component.ts"],"sourcesContent":["import {\n  createReactLayoutError,\n  type ReactLayoutErrorContext,\n} from './react-layout-error';\n\nconst scope = 'component' as const;\n\n/** Context describing an invalid or unconfigured component slot. */\nexport interface InvalidComponentContext\n  extends ReactLayoutErrorContext<typeof scope> {\n  component: unknown;\n  path?: string;\n  resource?: string;\n  validComponents?: readonly string[];\n  reason?: string;\n}\n\n/** Thrown when a requested component slot cannot be resolved. */\nexport class InvalidComponentError extends createReactLayoutError(\n  { code: 'invalidComponent', scope },\n)(\n  (\n    scope,\n    {\n      component,\n      path,\n      resource,\n      validComponents,\n      reason,\n    }: InvalidComponentContext,\n  ) => {\n    const quotedComponent =\n      JSON.stringify(component) ?? `\"${String(component)}\"`;\n    const locationParts = [\n      path ? `path \"${path}\"` : undefined,\n      resource ? `resource \"${resource}\"` : undefined,\n    ].filter((part): part is string => part !== undefined);\n    const locationMessage =\n      locationParts.length > 0 ? ` for ${locationParts.join(' and ')}` : '';\n    const body =\n      reason ??\n      `Component slot ${quotedComponent}${locationMessage} is not configured.`;\n    const validComponentsMessage =\n      validComponents && validComponents.length > 0\n        ? ` Available component slots are ${new Intl.ListFormat('en', {\n            style: 'long',\n            type: 'disjunction',\n          }).format(validComponents)}.`\n        : '';\n\n    return `[${scope}]: ${body}${validComponentsMessage}`;\n  },\n) {}\n"],"mappings":";;;AAKA,MAAM,QAAQ;;AAad,IAAa,wBAAb,cAA2C,uBACzC;CAAE,MAAM;CAAoB;AAAM,CACpC,GAEI,OACA,EACE,WACA,MACA,UACA,iBACA,aAEC;CACH,MAAM,kBACJ,KAAK,UAAU,SAAS,KAAK,IAAI,OAAO,SAAS,EAAE;CACrD,MAAM,gBAAgB,CACpB,OAAO,SAAS,KAAK,KAAK,QAC1B,WAAW,aAAa,SAAS,KAAK,MACxC,EAAE,QAAQ,SAAyB,SAAS,MAAS;CACrD,MAAM,kBACJ,cAAc,SAAS,IAAI,QAAQ,cAAc,KAAK,OAAO,MAAM;CAYrE,OAAO,IAAI,MAAM,KAVf,UACA,kBAAkB,kBAAkB,gBAAgB,uBAEpD,mBAAmB,gBAAgB,SAAS,IACxC,kCAAkC,IAAI,KAAK,WAAW,MAAM;EAC1D,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,eAAe,EAAE,KAC3B;AAGR,CACF,EAAE,CAAC"}
+{"version":3,"file":"invalid-component.mjs","names":[],"sources":["../../src/errors/invalid-component.ts"],"sourcesContent":["import { type } from 'arktype';\nimport { createReactLayoutError } from './react-layout-error';\n\nconst context = type({\n  component: 'unknown',\n  'path?': 'string',\n  'reason?': 'string',\n  'resource?': 'string',\n  scope: \"'component'\",\n  'validComponents?': 'string[]',\n});\n\nexport type InvalidComponentContext = typeof context.infer;\n\n/** Thrown when a requested component slot cannot be resolved. */\nexport class InvalidComponentError extends createReactLayoutError({\n  code: 'invalidComponent',\n  scope: 'component',\n})\n  .defineContext(context)\n  .implement(({ context, scope }) => {\n    const quotedComponent =\n      JSON.stringify(context.component) ?? `\"${String(context.component)}\"`;\n    const locationParts = [\n      context.path ? `path \"${context.path}\"` : undefined,\n      context.resource ? `resource \"${context.resource}\"` : undefined,\n    ].filter((part): part is string => part !== undefined);\n    const locationMessage =\n      locationParts.length > 0 ? ` for ${locationParts.join(' and ')}` : '';\n    const body =\n      context.reason ??\n      `Component slot ${quotedComponent}${locationMessage} is not configured.`;\n    const validComponentsMessage =\n      context.validComponents && context.validComponents.length > 0\n        ? ` Available component slots are ${new Intl.ListFormat('en', {\n            style: 'long',\n            type: 'disjunction',\n          }).format(context.validComponents)}.`\n        : '';\n\n    return `[${scope}]: ${body}${validComponentsMessage}`;\n  }) {}\n"],"mappings":";;;;AAGA,MAAM,UAAU,KAAK;CACnB,WAAW;CACX,SAAS;CACT,WAAW;CACX,aAAa;CACb,OAAO;CACP,oBAAoB;AACtB,CAAC;;AAKD,IAAa,wBAAb,cAA2C,uBAAuB;CAChE,MAAM;CACN,OAAO;AACT,CAAC,EACE,cAAc,OAAO,EACrB,WAAW,EAAE,SAAS,YAAY;CACjC,MAAM,kBACJ,KAAK,UAAU,QAAQ,SAAS,KAAK,IAAI,OAAO,QAAQ,SAAS,EAAE;CACrE,MAAM,gBAAgB,CACpB,QAAQ,OAAO,SAAS,QAAQ,KAAK,KAAK,QAC1C,QAAQ,WAAW,aAAa,QAAQ,SAAS,KAAK,MACxD,EAAE,QAAQ,SAAyB,SAAS,MAAS;CACrD,MAAM,kBACJ,cAAc,SAAS,IAAI,QAAQ,cAAc,KAAK,OAAO,MAAM;CAYrE,OAAO,IAAI,MAAM,KAVf,QAAQ,UACR,kBAAkB,kBAAkB,gBAAgB,uBAEpD,QAAQ,mBAAmB,QAAQ,gBAAgB,SAAS,IACxD,kCAAkC,IAAI,KAAK,WAAW,MAAM;EAC1D,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,QAAQ,eAAe,EAAE,KACnC;AAGR,CAAC,EAAE,CAAC"}

package/dist/errors/invalid-config.cjs

@@ -1,12 +1,17 @@
 const require_react_layout_error = require('./react-layout-error.cjs');
+let arktype = require("arktype");
 
 //#region src/errors/invalid-config.ts
-const scope = "config";
+const context = (0, arktype.type)({
+	"config?": "unknown",
+	reason: "string",
+	scope: "'config'"
+});
 /** Thrown when a React Layout configuration is invalid. */
 var InvalidConfigError = class extends require_react_layout_error.createReactLayoutError({
 	code: "invalidConfig",
-	scope
-})((scope, { reason }) => `[${scope}]: The layout configuration is invalid: ${reason}`) {};
+	scope: "config"
+}).defineContext(context).implement(({ context, scope }) => `[${scope}]: The layout configuration is invalid: ${context.reason}`) {};
 
 //#endregion
 exports.InvalidConfigError = InvalidConfigError;

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

@@ -1 +1 @@
-{"version":3,"file":"invalid-config.cjs","names":["createReactLayoutError"],"sources":["../../src/errors/invalid-config.ts"],"sourcesContent":["import {\n  createReactLayoutError,\n  type ReactLayoutErrorContext,\n} from './react-layout-error';\n\nconst scope = 'config' as const;\n\n/** Context describing a configuration that React Layout cannot use. */\nexport interface InvalidConfigContext\n  extends ReactLayoutErrorContext<typeof scope> {\n  reason: string;\n  config?: unknown;\n}\n\n/** Thrown when a React Layout configuration is invalid. */\nexport class InvalidConfigError extends createReactLayoutError(\n  { code: 'invalidConfig', scope },\n)(\n  (scope, { reason }: InvalidConfigContext) =>\n    `[${scope}]: The layout configuration is invalid: ${reason}`,\n) {}\n"],"mappings":";;;AAKA,MAAM,QAAQ;;AAUd,IAAa,qBAAb,cAAwCA,kDACtC;CAAE,MAAM;CAAiB;AAAM,CACjC,GACG,OAAO,EAAE,aACR,IAAI,MAAM,0CAA0C,QACxD,EAAE,CAAC"}
+{"version":3,"file":"invalid-config.cjs","names":["createReactLayoutError"],"sources":["../../src/errors/invalid-config.ts"],"sourcesContent":["import { type } from 'arktype';\nimport { createReactLayoutError } from './react-layout-error';\n\nconst context = type({\n  'config?': 'unknown',\n  reason: 'string',\n  scope: \"'config'\",\n});\n\nexport type InvalidConfigContext = typeof context.infer;\n\n/** Thrown when a React Layout configuration is invalid. */\nexport class InvalidConfigError extends createReactLayoutError({\n  code: 'invalidConfig',\n  scope: 'config',\n})\n  .defineContext(context)\n  .implement(\n    ({ context, scope }) =>\n      `[${scope}]: The layout configuration is invalid: ${context.reason}`,\n  ) {}\n"],"mappings":";;;;AAGA,MAAM,4BAAe;CACnB,WAAW;CACX,QAAQ;CACR,OAAO;AACT,CAAC;;AAKD,IAAa,qBAAb,cAAwCA,kDAAuB;CAC7D,MAAM;CACN,OAAO;AACT,CAAC,EACE,cAAc,OAAO,EACrB,WACE,EAAE,SAAS,YACV,IAAI,MAAM,0CAA0C,QAAQ,QAChE,EAAE,CAAC"}

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

@@ -1,13 +1,103 @@
-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-config.d.ts
-declare const scope: "config";
-/** Context describing a configuration that React Layout cannot use. */
-interface InvalidConfigContext extends ReactLayoutErrorContext<typeof scope> {
+declare const context: import("arktype/internal/variants/object.ts").ObjectType<{
   reason: string;
+  scope: "config";
   config?: unknown;
-}
-declare const InvalidConfigError_base: CreatedReactLayoutError<"invalidConfig", "config", InvalidConfigContext>;
+}, {}>;
+type InvalidConfigContext = typeof context.infer;
+declare const InvalidConfigError_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;
+}, {
+  reason: string;
+  scope: "config";
+  config?: unknown;
+}, {
+  reason: string;
+  scope: "config";
+  config?: unknown;
+}>;
 /** Thrown when a React Layout configuration is invalid. */
 declare class InvalidConfigError extends InvalidConfigError_base {}
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"invalid-config.d.cts","names":[],"sources":["../../src/errors/invalid-config.ts"],"mappings":";;;cAKM,KAAA;;UAGW,oBAAA,SACP,uBAAuB,QAAQ,KAAA;EACvC,MAAA;EACA,MAAA;AAAA;AAAA,cACD,uBAAA;AAJD;AAAA,cAOa,kBAAA,SAA2B,uBAKvC"}
+{"version":3,"file":"invalid-config.d.cts","names":[],"sources":["../../src/errors/invalid-config.ts"],"mappings":";;;cAGM,OAAA,gDAAO,UAAA;;;;;KAMD,oBAAA,UAA8B,OAAA,CAAQ,KAAK;AAAA,cAAC,uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAG3C,kBAAA,SAA2B,uBAQrC"}

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

@@ -1,13 +1,103 @@
-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-config.d.ts
-declare const scope: "config";
-/** Context describing a configuration that React Layout cannot use. */
-interface InvalidConfigContext extends ReactLayoutErrorContext<typeof scope> {
+declare const context: import("arktype/internal/variants/object.ts").ObjectType<{
   reason: string;
+  scope: "config";
   config?: unknown;
-}
-declare const InvalidConfigError_base: CreatedReactLayoutError<"invalidConfig", "config", InvalidConfigContext>;
+}, {}>;
+type InvalidConfigContext = typeof context.infer;
+declare const InvalidConfigError_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;
+}, {
+  reason: string;
+  scope: "config";
+  config?: unknown;
+}, {
+  reason: string;
+  scope: "config";
+  config?: unknown;
+}>;
 /** Thrown when a React Layout configuration is invalid. */
 declare class InvalidConfigError extends InvalidConfigError_base {}
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"invalid-config.d.mts","names":[],"sources":["../../src/errors/invalid-config.ts"],"mappings":";;;cAKM,KAAA;;UAGW,oBAAA,SACP,uBAAuB,QAAQ,KAAA;EACvC,MAAA;EACA,MAAA;AAAA;AAAA,cACD,uBAAA;AAJD;AAAA,cAOa,kBAAA,SAA2B,uBAKvC"}
+{"version":3,"file":"invalid-config.d.mts","names":[],"sources":["../../src/errors/invalid-config.ts"],"mappings":";;;cAGM,OAAA,gDAAO,UAAA;;;;;KAMD,oBAAA,UAA8B,OAAA,CAAQ,KAAK;AAAA,cAAC,uBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAG3C,kBAAA,SAA2B,uBAQrC"}

package/dist/errors/invalid-config.mjs

@@ -1,12 +1,17 @@
 import { createReactLayoutError } from "./react-layout-error.mjs";
+import { type } from "arktype";
 
 //#region src/errors/invalid-config.ts
-const scope = "config";
+const context = type({
+	"config?": "unknown",
+	reason: "string",
+	scope: "'config'"
+});
 /** Thrown when a React Layout configuration is invalid. */
 var InvalidConfigError = class extends createReactLayoutError({
 	code: "invalidConfig",
-	scope
-})((scope, { reason }) => `[${scope}]: The layout configuration is invalid: ${reason}`) {};
+	scope: "config"
+}).defineContext(context).implement(({ context, scope }) => `[${scope}]: The layout configuration is invalid: ${context.reason}`) {};
 
 //#endregion
 export { InvalidConfigError };

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

@@ -1 +1 @@
-{"version":3,"file":"invalid-config.mjs","names":[],"sources":["../../src/errors/invalid-config.ts"],"sourcesContent":["import {\n  createReactLayoutError,\n  type ReactLayoutErrorContext,\n} from './react-layout-error';\n\nconst scope = 'config' as const;\n\n/** Context describing a configuration that React Layout cannot use. */\nexport interface InvalidConfigContext\n  extends ReactLayoutErrorContext<typeof scope> {\n  reason: string;\n  config?: unknown;\n}\n\n/** Thrown when a React Layout configuration is invalid. */\nexport class InvalidConfigError extends createReactLayoutError(\n  { code: 'invalidConfig', scope },\n)(\n  (scope, { reason }: InvalidConfigContext) =>\n    `[${scope}]: The layout configuration is invalid: ${reason}`,\n) {}\n"],"mappings":";;;AAKA,MAAM,QAAQ;;AAUd,IAAa,qBAAb,cAAwC,uBACtC;CAAE,MAAM;CAAiB;AAAM,CACjC,GACG,OAAO,EAAE,aACR,IAAI,MAAM,0CAA0C,QACxD,EAAE,CAAC"}
+{"version":3,"file":"invalid-config.mjs","names":[],"sources":["../../src/errors/invalid-config.ts"],"sourcesContent":["import { type } from 'arktype';\nimport { createReactLayoutError } from './react-layout-error';\n\nconst context = type({\n  'config?': 'unknown',\n  reason: 'string',\n  scope: \"'config'\",\n});\n\nexport type InvalidConfigContext = typeof context.infer;\n\n/** Thrown when a React Layout configuration is invalid. */\nexport class InvalidConfigError extends createReactLayoutError({\n  code: 'invalidConfig',\n  scope: 'config',\n})\n  .defineContext(context)\n  .implement(\n    ({ context, scope }) =>\n      `[${scope}]: The layout configuration is invalid: ${context.reason}`,\n  ) {}\n"],"mappings":";;;;AAGA,MAAM,UAAU,KAAK;CACnB,WAAW;CACX,QAAQ;CACR,OAAO;AACT,CAAC;;AAKD,IAAa,qBAAb,cAAwC,uBAAuB;CAC7D,MAAM;CACN,OAAO;AACT,CAAC,EACE,cAAc,OAAO,EACrB,WACE,EAAE,SAAS,YACV,IAAI,MAAM,0CAA0C,QAAQ,QAChE,EAAE,CAAC"}

package/dist/errors/invalid-path.cjs

@@ -1,16 +1,22 @@
 const require_react_layout_error = require('./react-layout-error.cjs');
+let arktype = require("arktype");
 
 //#region src/errors/invalid-path.ts
-const scope = "path";
+const context = (0, arktype.type)({
+	path: "unknown",
+	"reason?": "string",
+	scope: "'path'",
+	"validPaths?": "string[]"
+});
 /** Thrown when a requested layout path is invalid or unavailable. */
 var InvalidPathError = class extends require_react_layout_error.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.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"invalid-path.cjs","names":["createReactLayoutError"],"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,cAAsCA,kDACpC;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.cjs","names":["createReactLayoutError"],"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,4BAAe;CACnB,MAAM;CACN,WAAW;CACX,OAAO;CACP,eAAe;AACjB,CAAC;;AAKD,IAAa,mBAAb,cAAsCA,kDAAuB;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"}