@diphyx/harlemify 3.0.0 → 4.0.1

package/dist/runtime/utils/endpoint.js

@@ -1,56 +0,0 @@
-import { capitalize } from "./transform.js";
-export var EndpointMethod = /* @__PURE__ */ ((EndpointMethod2) => {
-  EndpointMethod2["GET"] = "get";
-  EndpointMethod2["POST"] = "post";
-  EndpointMethod2["PUT"] = "put";
-  EndpointMethod2["PATCH"] = "patch";
-  EndpointMethod2["DELETE"] = "delete";
-  return EndpointMethod2;
-})(EndpointMethod || {});
-export var EndpointStatus = /* @__PURE__ */ ((EndpointStatus2) => {
-  EndpointStatus2["IDLE"] = "idle";
-  EndpointStatus2["PENDING"] = "pending";
-  EndpointStatus2["SUCCESS"] = "success";
-  EndpointStatus2["FAILED"] = "failed";
-  return EndpointStatus2;
-})(EndpointStatus || {});
-function createEndpointChain(method, url) {
-  return {
-    method,
-    url,
-    adapter: void 0,
-    withAdapter(adapter) {
-      return {
-        method,
-        url,
-        adapter
-      };
-    }
-  };
-}
-export const Endpoint = {
-  get(url) {
-    return createEndpointChain("get" /* GET */, url);
-  },
-  post(url) {
-    return createEndpointChain("post" /* POST */, url);
-  },
-  put(url) {
-    return createEndpointChain("put" /* PUT */, url);
-  },
-  patch(url) {
-    return createEndpointChain("patch" /* PATCH */, url);
-  },
-  delete(url) {
-    return createEndpointChain("delete" /* DELETE */, url);
-  }
-};
-export function makeEndpointStatusFlag(status) {
-  return `Is${capitalize(status)}`;
-}
-export function resolveEndpointUrl(endpoint, params) {
-  if (typeof endpoint.url === "function") {
-    return endpoint.url(params ?? {});
-  }
-  return endpoint.url;
-}

package/dist/runtime/utils/errors.d.ts

@@ -1,22 +0,0 @@
-export declare enum ApiErrorSource {
-    REQUEST = "request",
-    RESPONSE = "response"
-}
-export interface ApiErrorOptions {
-    source: ApiErrorSource;
-    method: string;
-    url: string;
-    message?: string;
-}
-export declare class ApiError extends Error {
-    source: ApiErrorSource;
-    method: string;
-    url: string;
-    constructor(options: ApiErrorOptions);
-}
-export declare class ApiRequestError extends ApiError {
-    constructor(options: Omit<ApiErrorOptions, "source">);
-}
-export declare class ApiResponseError extends ApiError {
-    constructor(options: Omit<ApiErrorOptions, "source">);
-}

package/dist/runtime/utils/errors.js

@@ -1,33 +0,0 @@
-export var ApiErrorSource = /* @__PURE__ */ ((ApiErrorSource2) => {
-  ApiErrorSource2["REQUEST"] = "request";
-  ApiErrorSource2["RESPONSE"] = "response";
-  return ApiErrorSource2;
-})(ApiErrorSource || {});
-export class ApiError extends Error {
-  source;
-  method;
-  url;
-  constructor(options) {
-    super(options.message ?? "Unknown error");
-    this.name = "ApiError";
-    this.source = options.source;
-    this.method = options.method;
-    this.url = options.url;
-  }
-}
-export class ApiRequestError extends ApiError {
-  constructor(options) {
-    super({
-      ...options,
-      source: "request" /* REQUEST */
-    });
-  }
-}
-export class ApiResponseError extends ApiError {
-  constructor(options) {
-    super({
-      ...options,
-      source: "response" /* RESPONSE */
-    });
-  }
-}

package/dist/runtime/utils/memory.d.ts

@@ -1,40 +0,0 @@
-export type MemoryTarget = "unit" | "units";
-export type MemoryMutation = "set" | "edit" | "drop" | "add";
-export interface EditOptions {
-    deep?: boolean;
-}
-export interface AddOptions {
-    prepend?: boolean;
-}
-export interface MemoryDefinition {
-    readonly on: MemoryTarget;
-    readonly path: string[];
-    readonly mutation?: MemoryMutation;
-    readonly prepend?: boolean;
-    readonly deep?: boolean;
-}
-export interface UnitMemoryBuilder<_S = unknown> extends MemoryDefinition {
-    set(): MemoryDefinition;
-    edit(options?: EditOptions): MemoryDefinition;
-    drop(): MemoryDefinition;
-}
-export interface UnitsMemoryBuilder<_S = unknown> extends MemoryDefinition {
-    set(): MemoryDefinition;
-    edit(options?: EditOptions): MemoryDefinition;
-    drop(): MemoryDefinition;
-    add(options?: AddOptions): MemoryDefinition;
-}
-export interface UnitFunction<S> {
-    (): UnitMemoryBuilder<S>;
-    <K extends keyof S & string>(key: K): UnitMemoryBuilder<S[K]>;
-    <K extends keyof S & string, K2 extends keyof S[K] & string>(key: K, nested: K2): UnitMemoryBuilder<S[K][K2]>;
-}
-export interface UnitsFunction<S> {
-    (): UnitsMemoryBuilder<S>;
-}
-export interface MemoryBuilder<S = unknown> {
-    unit: UnitFunction<S>;
-    units: UnitsFunction<S>;
-}
-export declare function createMemoryBuilder<S>(): MemoryBuilder<S>;
-export declare const Memory: MemoryBuilder<any>;

package/dist/runtime/utils/memory.js

@@ -1,87 +0,0 @@
-function createUnitMemoryBuilder(path = []) {
-  const definition = {
-    on: "unit",
-    path
-  };
-  return {
-    ...definition,
-    set() {
-      return {
-        on: "unit",
-        path,
-        mutation: "set"
-      };
-    },
-    edit(options) {
-      return {
-        on: "unit",
-        path,
-        mutation: "edit",
-        deep: options?.deep
-      };
-    },
-    drop() {
-      return {
-        on: "unit",
-        path,
-        mutation: "drop"
-      };
-    }
-  };
-}
-function createUnitsMemoryBuilder() {
-  const definition = {
-    on: "units",
-    path: []
-  };
-  return {
-    ...definition,
-    set() {
-      return {
-        on: "units",
-        path: [],
-        mutation: "set"
-      };
-    },
-    edit(options) {
-      return {
-        on: "units",
-        path: [],
-        mutation: "edit",
-        deep: options?.deep
-      };
-    },
-    drop() {
-      return {
-        on: "units",
-        path: [],
-        mutation: "drop"
-      };
-    },
-    add(options) {
-      return {
-        on: "units",
-        path: [],
-        mutation: "add",
-        prepend: options?.prepend
-      };
-    }
-  };
-}
-function createUnitFunction() {
-  return function unit(...keys) {
-    return createUnitMemoryBuilder(keys);
-  };
-}
-function createUnitsFunction() {
-  return function units() {
-    return createUnitsMemoryBuilder();
-  };
-}
-export function createMemoryBuilder() {
-  return {
-    unit: createUnitFunction(),
-    units: createUnitsFunction()
-  };
-}
-export const Memory = createMemoryBuilder();

package/dist/runtime/utils/schema.d.ts

@@ -1,23 +0,0 @@
-import type { z } from "zod";
-export interface SchemaMeta<A extends string = string> {
-    indicator?: boolean;
-    actions?: A[];
-}
-export declare function getMeta(field: any): SchemaMeta | undefined;
-export interface SchemaFieldInfo<A extends string = string> {
-    name: string;
-    indicator: boolean;
-    actions: A[];
-}
-export declare function getSchemaFields<T extends z.ZodRawShape, A extends string = string>(schema: z.ZodObject<T>): SchemaFieldInfo<A>[];
-export declare function getFieldsForAction<T extends z.ZodRawShape, A extends string = string>(schema: z.ZodObject<T>, action: A): string[];
-export interface ResolveSchemaOptions<S> {
-    indicator?: keyof S;
-    action?: string;
-    unit?: Partial<S>;
-}
-export declare function resolveSchema<T extends z.ZodRawShape, S extends z.infer<z.ZodObject<T>>>(schema: z.ZodObject<T>, options?: ResolveSchemaOptions<S>): {
-    indicator: keyof S;
-    keys: Record<keyof S, true>;
-    values: Partial<S>;
-};

package/dist/runtime/utils/schema.js

@@ -1,58 +0,0 @@
-export function getMeta(field) {
-  return field.meta();
-}
-const schemaFieldsCache = /* @__PURE__ */ new WeakMap();
-export function getSchemaFields(schema) {
-  const cached = schemaFieldsCache.get(schema);
-  if (cached) {
-    return cached;
-  }
-  const fields = [];
-  for (const key in schema.shape) {
-    const meta = getMeta(schema.shape[key]);
-    fields.push({
-      name: key,
-      indicator: meta?.indicator ?? false,
-      actions: meta?.actions ?? []
-    });
-  }
-  schemaFieldsCache.set(schema, fields);
-  return fields;
-}
-export function getFieldsForAction(schema, action) {
-  const fields = [];
-  for (const key in schema.shape) {
-    const meta = getMeta(schema.shape[key]);
-    if (meta?.actions) {
-      const actionsSet = new Set(meta.actions);
-      if (actionsSet.has(action)) {
-        fields.push(key);
-      }
-    }
-  }
-  return fields;
-}
-export function resolveSchema(schema, options) {
-  const output = {
-    indicator: options?.indicator ?? "id",
-    keys: {},
-    values: {}
-  };
-  for (const key in schema.shape) {
-    const meta = getMeta(schema.shape[key]);
-    if (meta?.indicator) {
-      output.indicator = key;
-    }
-    if (!options?.action || !meta?.actions) {
-      continue;
-    }
-    const actionsSet = new Set(meta.actions);
-    if (actionsSet.has(options.action)) {
-      output.keys[key] = true;
-      if (options?.unit && key in options.unit) {
-        output.values[key] = options.unit[key];
-      }
-    }
-  }
-  return output;
-}

package/dist/runtime/utils/transform.d.ts

@@ -1,6 +0,0 @@
-type IsVowel<C extends string> = C extends "a" | "e" | "i" | "o" | "u" ? true : false;
-export type Pluralize<S extends string> = S extends `${infer Base}y` ? Base extends `${infer _Rest}${infer Last}` ? IsVowel<Last> extends true ? `${S}s` : `${Base}ies` : `${S}s` : S extends `${string}${"s" | "x" | "z"}` ? `${S}es` : S extends `${string}${"ch" | "sh"}` ? `${S}es` : `${S}s`;
-export declare function pluralize<S extends string>(word: S): Pluralize<S>;
-export type Capitalize<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
-export declare function capitalize<S extends string>(str: S): Capitalize<S>;
-export {};

package/dist/runtime/utils/transform.js

@@ -1,22 +0,0 @@
-const VOWELS = /* @__PURE__ */ new Set(["a", "e", "i", "o", "u"]);
-const SIBILANTS = /* @__PURE__ */ new Set(["s", "x", "z"]);
-const SIBILANT_PAIRS = /* @__PURE__ */ new Set(["ch", "sh"]);
-export function pluralize(word) {
-  if (!word) return word;
-  const lastChar = word.slice(-1).toLowerCase();
-  const lastTwo = word.slice(-2).toLowerCase();
-  const beforeLast = word.slice(-2, -1).toLowerCase();
-  if (lastChar === "y" && !VOWELS.has(beforeLast)) {
-    return word.slice(0, -1) + "ies";
-  }
-  if (SIBILANTS.has(lastChar)) {
-    return word + "es";
-  }
-  if (SIBILANT_PAIRS.has(lastTwo)) {
-    return word + "es";
-  }
-  return word + "s";
-}
-export function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
-}