@jfdevelops/react-layout 0.22.0 → 0.23.0

package/dist/errors/layout-configuration-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-configuration-error.mjs","names":[],"sources":["../../src/errors/layout-configuration-error.ts"],"sourcesContent":["import { type } from 'arktype';\nimport { createReactLayoutError } from './react-layout-error';\n\nconst context = type('string').pipe((message) => ({\n  message,\n  scope: 'configuration',\n}));\n\nexport type LayoutConfigurationErrorContext = typeof context.infer;\n\n/** Thrown when a layout or resource configuration cannot be used. */\nexport class LayoutConfigurationError extends createReactLayoutError({\n  code: 'layoutConfiguration',\n  scope: 'configuration',\n})\n  .defineContext(context)\n  .implement(({ context }) => context.message) {}\n"],"mappings":";;;;AAGA,MAAM,UAAU,KAAK,QAAQ,EAAE,MAAM,aAAa;CAChD;CACA,OAAO;AACT,EAAE;;AAKF,IAAa,2BAAb,cAA8C,uBAAuB;CACnE,MAAM;CACN,OAAO;AACT,CAAC,EACE,cAAc,OAAO,EACrB,WAAW,EAAE,cAAc,QAAQ,OAAO,EAAE,CAAC"}

package/dist/errors/missing-path-variable.cjs

@@ -1,16 +1,23 @@
 const require_react_layout_error = require('./react-layout-error.cjs');
+let arktype = require("arktype");
 
 //#region src/errors/missing-path-variable.ts
-const scope = "pathVariable";
+const context = (0, arktype.type)({
+	path: "string",
+	"providedVariables?": "string[]",
+	scope: "'pathVariable'",
+	variable: "string"
+});
 /** Thrown when a required layout path variable was not provided. */
 var MissingPathVariableError = class extends require_react_layout_error.createReactLayoutError({
 	code: "missingPathVariable",
-	scope
-})((scope, { variable, path, providedVariables }) => {
-	return `[${scope}]: Path "${path}" requires $${variable}.${providedVariables && providedVariables.length > 0 ? ` Provided variables were ${new Intl.ListFormat("en", {
+	scope: "pathVariable"
+}).defineContext(context).implement(({ context, scope }) => {
+	const providedMessage = context.providedVariables && context.providedVariables.length > 0 ? ` Provided variables were ${new Intl.ListFormat("en", {
 		style: "long",
 		type: "disjunction"
-	}).format(providedVariables.map((provided) => `$${provided}`))}.` : " No path variables were provided."}`;
+	}).format(context.providedVariables.map((provided) => `$${provided}`))}.` : " No path variables were provided.";
+	return `[${scope}]: Path "${context.path}" requires $${context.variable}.${providedMessage}`;
 }) {};
 
 //#endregion

package/dist/errors/missing-path-variable.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"missing-path-variable.cjs","names":["createReactLayoutError"],"sources":["../../src/errors/missing-path-variable.ts"],"sourcesContent":["import {\n  createReactLayoutError,\n  type ReactLayoutErrorContext,\n} from './react-layout-error';\n\nconst scope = 'pathVariable' as const;\n\n/** Context describing a variable required to resolve a layout path. */\nexport interface MissingPathVariableContext\n  extends ReactLayoutErrorContext<typeof scope> {\n  variable: string;\n  path: string;\n  providedVariables?: readonly string[];\n}\n\n/** Thrown when a required layout path variable was not provided. */\nexport class MissingPathVariableError extends createReactLayoutError(\n  { code: 'missingPathVariable', scope },\n)(\n  (\n    scope,\n    { variable, path, providedVariables }: MissingPathVariableContext,\n  ) => {\n    const providedMessage =\n      providedVariables && providedVariables.length > 0\n        ? ` Provided variables were ${new Intl.ListFormat('en', {\n            style: 'long',\n            type: 'disjunction',\n          }).format(providedVariables.map((provided) => `$${provided}`))}.`\n        : ' No path variables were provided.';\n\n    return `[${scope}]: Path \"${path}\" requires $${variable}.${providedMessage}`;\n  },\n) {}\n"],"mappings":";;;AAKA,MAAM,QAAQ;;AAWd,IAAa,2BAAb,cAA8CA,kDAC5C;CAAE,MAAM;CAAuB;AAAM,CACvC,GAEI,OACA,EAAE,UAAU,MAAM,wBACf;CASH,OAAO,IAAI,MAAM,WAAW,KAAK,cAAc,SAAS,GAPtD,qBAAqB,kBAAkB,SAAS,IAC5C,4BAA4B,IAAI,KAAK,WAAW,MAAM;EACpD,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,kBAAkB,KAAK,aAAa,IAAI,UAAU,CAAC,EAAE,KAC/D;AAGR,CACF,EAAE,CAAC"}
+{"version":3,"file":"missing-path-variable.cjs","names":["createReactLayoutError"],"sources":["../../src/errors/missing-path-variable.ts"],"sourcesContent":["import { type } from 'arktype';\nimport { createReactLayoutError } from './react-layout-error';\n\nconst context = type({\n  path: 'string',\n  'providedVariables?': 'string[]',\n  scope: \"'pathVariable'\",\n  variable: 'string',\n});\n\nexport type MissingPathVariableContext = typeof context.infer;\n\n/** Thrown when a required layout path variable was not provided. */\nexport class MissingPathVariableError extends createReactLayoutError({\n  code: 'missingPathVariable',\n  scope: 'pathVariable',\n})\n  .defineContext(context)\n  .implement(({ context, scope }) => {\n    const providedMessage =\n      context.providedVariables && context.providedVariables.length > 0\n        ? ` Provided variables were ${new Intl.ListFormat('en', {\n            style: 'long',\n            type: 'disjunction',\n          }).format(context.providedVariables.map((provided) => `$${provided}`))}.`\n        : ' No path variables were provided.';\n\n    return `[${scope}]: Path \"${context.path}\" requires $${context.variable}.${providedMessage}`;\n  }) {}\n"],"mappings":";;;;AAGA,MAAM,4BAAe;CACnB,MAAM;CACN,sBAAsB;CACtB,OAAO;CACP,UAAU;AACZ,CAAC;;AAKD,IAAa,2BAAb,cAA8CA,kDAAuB;CACnE,MAAM;CACN,OAAO;AACT,CAAC,EACE,cAAc,OAAO,EACrB,WAAW,EAAE,SAAS,YAAY;CACjC,MAAM,kBACJ,QAAQ,qBAAqB,QAAQ,kBAAkB,SAAS,IAC5D,4BAA4B,IAAI,KAAK,WAAW,MAAM;EACpD,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,QAAQ,kBAAkB,KAAK,aAAa,IAAI,UAAU,CAAC,EAAE,KACvE;CAEN,OAAO,IAAI,MAAM,WAAW,QAAQ,KAAK,cAAc,QAAQ,SAAS,GAAG;AAC7E,CAAC,EAAE,CAAC"}

package/dist/errors/missing-path-variable.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/missing-path-variable.d.ts
-declare const scope: "pathVariable";
-/** Context describing a variable required to resolve a layout path. */
-interface MissingPathVariableContext extends ReactLayoutErrorContext<typeof scope> {
+declare const context: import("arktype/internal/variants/object.ts").ObjectType<{
+  path: string;
+  scope: "pathVariable";
+  variable: string;
+  providedVariables?: string[] | undefined;
+}, {}>;
+type MissingPathVariableContext = typeof context.infer;
+declare const MissingPathVariableError_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: string;
+  scope: "pathVariable";
   variable: string;
+  providedVariables?: string[] | undefined;
+}, {
   path: string;
-  providedVariables?: readonly string[];
-}
-declare const MissingPathVariableError_base: CreatedReactLayoutError<"missingPathVariable", "pathVariable", MissingPathVariableContext>;
+  scope: "pathVariable";
+  variable: string;
+  providedVariables?: string[] | undefined;
+}>;
 /** Thrown when a required layout path variable was not provided. */
 declare class MissingPathVariableError extends MissingPathVariableError_base {}
 //#endregion

package/dist/errors/missing-path-variable.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"missing-path-variable.d.cts","names":[],"sources":["../../src/errors/missing-path-variable.ts"],"mappings":";;;cAKM,KAAA;;UAGW,0BAAA,SACP,uBAAuB,QAAQ,KAAA;EACvC,QAAA;EACA,IAAA;EACA,iBAAA;AAAA;AAAA,cACD,6BAAA;;cAGY,wBAAA,SAAiC,6BAiB7C"}
+{"version":3,"file":"missing-path-variable.d.cts","names":[],"sources":["../../src/errors/missing-path-variable.ts"],"mappings":";;;cAGM,OAAA,gDAAO,UAAA;;;;;;KAOD,0BAAA,UAAoC,OAAA,CAAQ,KAAK;AAAA,cAAC,6BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjD,wBAAA,SAAiC,6BAe1C"}

package/dist/errors/missing-path-variable.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/missing-path-variable.d.ts
-declare const scope: "pathVariable";
-/** Context describing a variable required to resolve a layout path. */
-interface MissingPathVariableContext extends ReactLayoutErrorContext<typeof scope> {
+declare const context: import("arktype/internal/variants/object.ts").ObjectType<{
+  path: string;
+  scope: "pathVariable";
+  variable: string;
+  providedVariables?: string[] | undefined;
+}, {}>;
+type MissingPathVariableContext = typeof context.infer;
+declare const MissingPathVariableError_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: string;
+  scope: "pathVariable";
   variable: string;
+  providedVariables?: string[] | undefined;
+}, {
   path: string;
-  providedVariables?: readonly string[];
-}
-declare const MissingPathVariableError_base: CreatedReactLayoutError<"missingPathVariable", "pathVariable", MissingPathVariableContext>;
+  scope: "pathVariable";
+  variable: string;
+  providedVariables?: string[] | undefined;
+}>;
 /** Thrown when a required layout path variable was not provided. */
 declare class MissingPathVariableError extends MissingPathVariableError_base {}
 //#endregion

package/dist/errors/missing-path-variable.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"missing-path-variable.d.mts","names":[],"sources":["../../src/errors/missing-path-variable.ts"],"mappings":";;;cAKM,KAAA;;UAGW,0BAAA,SACP,uBAAuB,QAAQ,KAAA;EACvC,QAAA;EACA,IAAA;EACA,iBAAA;AAAA;AAAA,cACD,6BAAA;;cAGY,wBAAA,SAAiC,6BAiB7C"}
+{"version":3,"file":"missing-path-variable.d.mts","names":[],"sources":["../../src/errors/missing-path-variable.ts"],"mappings":";;;cAGM,OAAA,gDAAO,UAAA;;;;;;KAOD,0BAAA,UAAoC,OAAA,CAAQ,KAAK;AAAA,cAAC,6BAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGjD,wBAAA,SAAiC,6BAe1C"}

package/dist/errors/missing-path-variable.mjs

@@ -1,16 +1,23 @@
 import { createReactLayoutError } from "./react-layout-error.mjs";
+import { type } from "arktype";
 
 //#region src/errors/missing-path-variable.ts
-const scope = "pathVariable";
+const context = type({
+	path: "string",
+	"providedVariables?": "string[]",
+	scope: "'pathVariable'",
+	variable: "string"
+});
 /** Thrown when a required layout path variable was not provided. */
 var MissingPathVariableError = class extends createReactLayoutError({
 	code: "missingPathVariable",
-	scope
-})((scope, { variable, path, providedVariables }) => {
-	return `[${scope}]: Path "${path}" requires $${variable}.${providedVariables && providedVariables.length > 0 ? ` Provided variables were ${new Intl.ListFormat("en", {
+	scope: "pathVariable"
+}).defineContext(context).implement(({ context, scope }) => {
+	const providedMessage = context.providedVariables && context.providedVariables.length > 0 ? ` Provided variables were ${new Intl.ListFormat("en", {
 		style: "long",
 		type: "disjunction"
-	}).format(providedVariables.map((provided) => `$${provided}`))}.` : " No path variables were provided."}`;
+	}).format(context.providedVariables.map((provided) => `$${provided}`))}.` : " No path variables were provided.";
+	return `[${scope}]: Path "${context.path}" requires $${context.variable}.${providedMessage}`;
 }) {};
 
 //#endregion

package/dist/errors/missing-path-variable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"missing-path-variable.mjs","names":[],"sources":["../../src/errors/missing-path-variable.ts"],"sourcesContent":["import {\n  createReactLayoutError,\n  type ReactLayoutErrorContext,\n} from './react-layout-error';\n\nconst scope = 'pathVariable' as const;\n\n/** Context describing a variable required to resolve a layout path. */\nexport interface MissingPathVariableContext\n  extends ReactLayoutErrorContext<typeof scope> {\n  variable: string;\n  path: string;\n  providedVariables?: readonly string[];\n}\n\n/** Thrown when a required layout path variable was not provided. */\nexport class MissingPathVariableError extends createReactLayoutError(\n  { code: 'missingPathVariable', scope },\n)(\n  (\n    scope,\n    { variable, path, providedVariables }: MissingPathVariableContext,\n  ) => {\n    const providedMessage =\n      providedVariables && providedVariables.length > 0\n        ? ` Provided variables were ${new Intl.ListFormat('en', {\n            style: 'long',\n            type: 'disjunction',\n          }).format(providedVariables.map((provided) => `$${provided}`))}.`\n        : ' No path variables were provided.';\n\n    return `[${scope}]: Path \"${path}\" requires $${variable}.${providedMessage}`;\n  },\n) {}\n"],"mappings":";;;AAKA,MAAM,QAAQ;;AAWd,IAAa,2BAAb,cAA8C,uBAC5C;CAAE,MAAM;CAAuB;AAAM,CACvC,GAEI,OACA,EAAE,UAAU,MAAM,wBACf;CASH,OAAO,IAAI,MAAM,WAAW,KAAK,cAAc,SAAS,GAPtD,qBAAqB,kBAAkB,SAAS,IAC5C,4BAA4B,IAAI,KAAK,WAAW,MAAM;EACpD,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,kBAAkB,KAAK,aAAa,IAAI,UAAU,CAAC,EAAE,KAC/D;AAGR,CACF,EAAE,CAAC"}
+{"version":3,"file":"missing-path-variable.mjs","names":[],"sources":["../../src/errors/missing-path-variable.ts"],"sourcesContent":["import { type } from 'arktype';\nimport { createReactLayoutError } from './react-layout-error';\n\nconst context = type({\n  path: 'string',\n  'providedVariables?': 'string[]',\n  scope: \"'pathVariable'\",\n  variable: 'string',\n});\n\nexport type MissingPathVariableContext = typeof context.infer;\n\n/** Thrown when a required layout path variable was not provided. */\nexport class MissingPathVariableError extends createReactLayoutError({\n  code: 'missingPathVariable',\n  scope: 'pathVariable',\n})\n  .defineContext(context)\n  .implement(({ context, scope }) => {\n    const providedMessage =\n      context.providedVariables && context.providedVariables.length > 0\n        ? ` Provided variables were ${new Intl.ListFormat('en', {\n            style: 'long',\n            type: 'disjunction',\n          }).format(context.providedVariables.map((provided) => `$${provided}`))}.`\n        : ' No path variables were provided.';\n\n    return `[${scope}]: Path \"${context.path}\" requires $${context.variable}.${providedMessage}`;\n  }) {}\n"],"mappings":";;;;AAGA,MAAM,UAAU,KAAK;CACnB,MAAM;CACN,sBAAsB;CACtB,OAAO;CACP,UAAU;AACZ,CAAC;;AAKD,IAAa,2BAAb,cAA8C,uBAAuB;CACnE,MAAM;CACN,OAAO;AACT,CAAC,EACE,cAAc,OAAO,EACrB,WAAW,EAAE,SAAS,YAAY;CACjC,MAAM,kBACJ,QAAQ,qBAAqB,QAAQ,kBAAkB,SAAS,IAC5D,4BAA4B,IAAI,KAAK,WAAW,MAAM;EACpD,OAAO;EACP,MAAM;CACR,CAAC,EAAE,OAAO,QAAQ,kBAAkB,KAAK,aAAa,IAAI,UAAU,CAAC,EAAE,KACvE;CAEN,OAAO,IAAI,MAAM,WAAW,QAAQ,KAAK,cAAc,QAAQ,SAAS,GAAG;AAC7E,CAAC,EAAE,CAAC"}

package/dist/errors/missing-resource-provider.cjs

@@ -0,0 +1,12 @@
+const require_react_layout_error = require('./react-layout-error.cjs');
+
+//#region src/errors/missing-resource-provider.ts
+/** Thrown when `useResource` is called outside its resource provider. */
+var MissingResourceProviderError = class extends require_react_layout_error.createReactLayoutError({
+	code: "missingResourceProvider",
+	scope: "resourceContext"
+}).implement(({ scope }) => `[${scope}]: useResource must be called within its ResourceProvider.`) {};
+
+//#endregion
+exports.MissingResourceProviderError = MissingResourceProviderError;
+//# sourceMappingURL=missing-resource-provider.cjs.map

package/dist/errors/missing-resource-provider.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"missing-resource-provider.cjs","names":["createReactLayoutError"],"sources":["../../src/errors/missing-resource-provider.ts"],"sourcesContent":["import { createReactLayoutError } from './react-layout-error';\n\n/** Thrown when `useResource` is called outside its resource provider. */\nexport class MissingResourceProviderError extends createReactLayoutError({\n  code: 'missingResourceProvider',\n  scope: 'resourceContext',\n}).implement(\n  ({ scope }) =>\n    `[${scope}]: useResource must be called within its ResourceProvider.`,\n) {}\n"],"mappings":";;;;AAGA,IAAa,+BAAb,cAAkDA,kDAAuB;CACvE,MAAM;CACN,OAAO;AACT,CAAC,EAAE,WACA,EAAE,YACD,IAAI,MAAM,2DACd,EAAE,CAAC"}

package/dist/errors/missing-resource-provider.d.cts

@@ -0,0 +1,91 @@
+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/missing-resource-provider.d.ts
+declare const MissingResourceProviderError_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;
+}, unknown, unknown>;
+/** Thrown when `useResource` is called outside its resource provider. */
+declare class MissingResourceProviderError extends MissingResourceProviderError_base {}
+//#endregion
+export { MissingResourceProviderError };
+//# sourceMappingURL=missing-resource-provider.d.cts.map

package/dist/errors/missing-resource-provider.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"missing-resource-provider.d.cts","names":[],"sources":["../../src/errors/missing-resource-provider.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGa,4BAAA,SAAqC,iCAMjD"}

package/dist/errors/missing-resource-provider.d.mts

@@ -0,0 +1,91 @@
+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/missing-resource-provider.d.ts
+declare const MissingResourceProviderError_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;
+}, unknown, unknown>;
+/** Thrown when `useResource` is called outside its resource provider. */
+declare class MissingResourceProviderError extends MissingResourceProviderError_base {}
+//#endregion
+export { MissingResourceProviderError };
+//# sourceMappingURL=missing-resource-provider.d.mts.map

package/dist/errors/missing-resource-provider.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"missing-resource-provider.d.mts","names":[],"sources":["../../src/errors/missing-resource-provider.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAGa,4BAAA,SAAqC,iCAMjD"}

package/dist/errors/missing-resource-provider.mjs

@@ -0,0 +1,12 @@
+import { createReactLayoutError } from "./react-layout-error.mjs";
+
+//#region src/errors/missing-resource-provider.ts
+/** Thrown when `useResource` is called outside its resource provider. */
+var MissingResourceProviderError = class extends createReactLayoutError({
+	code: "missingResourceProvider",
+	scope: "resourceContext"
+}).implement(({ scope }) => `[${scope}]: useResource must be called within its ResourceProvider.`) {};
+
+//#endregion
+export { MissingResourceProviderError };
+//# sourceMappingURL=missing-resource-provider.mjs.map

package/dist/errors/missing-resource-provider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"missing-resource-provider.mjs","names":[],"sources":["../../src/errors/missing-resource-provider.ts"],"sourcesContent":["import { createReactLayoutError } from './react-layout-error';\n\n/** Thrown when `useResource` is called outside its resource provider. */\nexport class MissingResourceProviderError extends createReactLayoutError({\n  code: 'missingResourceProvider',\n  scope: 'resourceContext',\n}).implement(\n  ({ scope }) =>\n    `[${scope}]: useResource must be called within its ResourceProvider.`,\n) {}\n"],"mappings":";;;;AAGA,IAAa,+BAAb,cAAkD,uBAAuB;CACvE,MAAM;CACN,OAAO;AACT,CAAC,EAAE,WACA,EAAE,YACD,IAAI,MAAM,2DACd,EAAE,CAAC"}