@bccampus/ui-components 0.3.0 → 0.4.1

package/dist/generate-tiles-DuagGD1d.js

@@ -0,0 +1,244 @@
+import { jsx as n } from "react/jsx-runtime";
+import { c as m } from "./utils-CRiPKpXj.js";
+const r = {
+  Blank: 0,
+  Rand: 1,
+  Mosaic: 2,
+  MosaicCircle: 3,
+  MosaicDiamond: 4,
+  Square: 6,
+  Circle: 7,
+  Diamond: 8,
+  Hexagon: 9,
+  RandBasic: 10,
+  TriangleSE: 11,
+  TriangleSW: 12,
+  TriangleNW: 13,
+  TriangleNE: 14,
+  TriangleRand: 15,
+  CaretN: 16,
+  CaretE: 17,
+  CaretS: 18,
+  CaretW: 19,
+  CaretRand: 20,
+  PieSE: 21,
+  PieSW: 22,
+  PieNW: 23,
+  PieNE: 24,
+  PieRand: 25
+}, p = [
+  r.Square,
+  r.Circle,
+  r.Diamond,
+  r.Hexagon,
+  r.TriangleSE,
+  r.TriangleSW,
+  r.TriangleNW,
+  r.TriangleNE,
+  r.PieSE,
+  r.PieSW,
+  r.PieNW,
+  r.PieNE
+], h = {
+  [r.Blank]: () => null,
+  [r.Rand]: (c, $, a, s) => h[p[Math.floor(Math.random() * p.length)]](c, $, a, s),
+  [r.Mosaic]: (c, $, a, s) => h[Math.random() > 0.8 ? r.Blank : r.Square](c, $, a, s),
+  [r.MosaicCircle]: (c, $, a, s) => h[Math.random() > 0.8 ? r.Blank : r.Circle](c, $, a, s),
+  [r.MosaicDiamond]: (c, $, a, s) => h[Math.random() > 0.8 ? r.Blank : r.Diamond](c, $, a, s),
+  [r.Square]: (c, $, a, s) => /* @__PURE__ */ n(
+    "rect",
+    {
+      x: a * c,
+      y: a * $,
+      width: a * s.scale,
+      height: a * s.scale,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.Circle]: (c, $, a, s) => /* @__PURE__ */ n(
+    "circle",
+    {
+      cx: a * (c + 0.5 * s.scale),
+      cy: a * ($ + 0.5 * s.scale),
+      r: a / 2 * s.scale,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.Diamond]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * (c + 0.5 * s.scale)} ${a * $} 
+      L ${a * (c + s.scale)} ${a * ($ + 0.5 * s.scale)} 
+      L ${a * (c + 0.5 * s.scale)} ${a * ($ + s.scale)} 
+      L ${a * c} ${a * ($ + 0.5 * s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.Hexagon]: (c, $, a, s) => {
+    const d = a / Math.sqrt(3), N = (a - d) / 2;
+    return /* @__PURE__ */ n(
+      "path",
+      {
+        rotate: 45,
+        d: `M ${a * c + N * s.scale} ${a * $}
+        L ${a * c + (N + d) * s.scale} ${a * $}
+        L ${a * (c + s.scale)} ${a * ($ + 0.5 * s.scale)}
+        L ${a * c + (N + d) * s.scale} ${a * ($ + s.scale)}
+        L ${a * c + N * s.scale} ${a * ($ + s.scale)}
+        L ${a * c} ${a * ($ + 0.5 * s.scale)}  Z`,
+        className: m("fill-current stroke-none", s?.className)
+      },
+      `tile-${c}-${$}`
+    );
+  },
+  [r.RandBasic]: (c, $, a, s) => h[r.Square + Math.floor(Math.random() * 4)](c, $, a, s),
+  [r.TriangleSE]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * (c + s.scale)} ${a * $} 
+      L ${a * c} ${a * ($ + s.scale)} 
+      L ${a * (c + s.scale)} ${a * ($ + s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.TriangleSW]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * $} 
+      L ${a * (c + s.scale)} ${a * ($ + s.scale)} 
+      L ${a * c} ${a * ($ + s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.TriangleNW]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * (c + s.scale)} ${a * $} 
+      L ${a * c} ${a * ($ + s.scale)} 
+      L ${a * c} ${a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.TriangleNE]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * $} 
+      L ${a * (c + s.scale)} ${a * ($ + s.scale)} 
+      L ${a * (c + s.scale)} ${a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.TriangleRand]: (c, $, a, s) => h[r.TriangleSE + Math.floor(Math.random() * 4)](
+    c,
+    $,
+    a,
+    s
+  ),
+  [r.CaretN]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * ($ + s.scale)} 
+      L ${a * (c + s.scale)} ${a * ($ + s.scale)} 
+      L ${a * (c + 0.5 * s.scale)} ${a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.CaretE]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * $} 
+      L ${a * (c + s.scale)} ${a * ($ + 0.5 * s.scale)} 
+      L ${a * c} ${a * ($ + s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.CaretS]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * $} 
+      L ${a * (c + s.scale)} ${a * $} 
+      L ${a * (c + 0.5 * s.scale)} ${a * ($ + s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.CaretW]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * (c + s.scale)} ${a * $} 
+      L ${a * c} ${a * ($ + 0.5 * s.scale)} 
+      L ${a * (c + s.scale)} ${a * ($ + s.scale)}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.CaretRand]: (c, $, a, s) => h[r.CaretN + Math.floor(Math.random() * 4)](c, $, a, s),
+  [r.PieSE]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * s.scale + a * c} ${a * $} 
+      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * c} ${a * s.scale + a * $} 
+      L ${a * s.scale + a * c} ${a * s.scale + a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.PieSW]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * s.scale + a * c} ${a * s.scale + a * $} 
+      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * c} ${a * $} 
+      L ${a * c} ${a * s.scale + a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.PieNW]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * s.scale + a * $} 
+      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * s.scale + a * c} ${a * $} 
+      L ${a * c} ${a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.PieNE]: (c, $, a, s) => /* @__PURE__ */ n(
+    "path",
+    {
+      d: `M ${a * c} ${a * $} 
+      A ${a * s.scale} ${a * s.scale}, 0, 0, 0, ${a * s.scale + a * c} ${a * s.scale + a * $} 
+      L ${a * s.scale + a * c} ${a * $}  Z`,
+      className: m("fill-current stroke-none", s?.className)
+    },
+    `tile-${c}-${$}`
+  ),
+  [r.PieRand]: (c, $, a, s) => h[r.PieSE + Math.floor(Math.random() * 4)](c, $, a, s)
+}, o = (c, $, a) => {
+  const s = [];
+  for (let d = 0; d < $; d++) {
+    s[d] = [];
+    for (let N = 0; N < c; N++)
+      s[d].push(a);
+  }
+  return s;
+}, T = (c, $, a) => c.map(
+  (s, d) => s.map((N, L) => {
+    const M = typeof N == "object" ? { className: m(a, N.className), scale: N.scale ?? 1, shape: N.shape } : { className: a, scale: 1, shape: N };
+    return h[M.shape](L, d, $, M);
+  })
+).flat();
+export {
+  r as T,
+  o as a,
+  T as g
+};

package/dist/generate-tiles.d.ts

@@ -0,0 +1,43 @@
+import { JSX } from 'react';
+
+export declare const generateIconPattern: (width: number, height: number, tileConfig: TileShape | TileConfig) => (TileShape | TileConfig)[][];
+
+export declare const generateTiles: (pattern: (TileShape | TileConfig)[][], tileSize: number, tileClassName?: string) => (JSX.Element | null)[];
+
+declare interface TileConfig {
+    shape: TileShape;
+    scale?: number;
+    className?: string;
+}
+
+declare const TileShape: {
+    readonly Blank: 0;
+    readonly Rand: 1;
+    readonly Mosaic: 2;
+    readonly MosaicCircle: 3;
+    readonly MosaicDiamond: 4;
+    readonly Square: 6;
+    readonly Circle: 7;
+    readonly Diamond: 8;
+    readonly Hexagon: 9;
+    readonly RandBasic: 10;
+    readonly TriangleSE: 11;
+    readonly TriangleSW: 12;
+    readonly TriangleNW: 13;
+    readonly TriangleNE: 14;
+    readonly TriangleRand: 15;
+    readonly CaretN: 16;
+    readonly CaretE: 17;
+    readonly CaretS: 18;
+    readonly CaretW: 19;
+    readonly CaretRand: 20;
+    readonly PieSE: 21;
+    readonly PieSW: 22;
+    readonly PieNW: 23;
+    readonly PieNE: 24;
+    readonly PieRand: 25;
+};
+
+declare type TileShape = (typeof TileShape)[keyof typeof TileShape];
+
+export { }

package/dist/generate-tiles.js

@@ -0,0 +1,7 @@
+import "react/jsx-runtime";
+import "./utils-CRiPKpXj.js";
+import { a as o, g as n } from "./generate-tiles-DuagGD1d.js";
+export {
+  o as generateIconPattern,
+  n as generateTiles
+};

package/dist/icon-generator-tuhuqdpL.js

@@ -0,0 +1,76 @@
+import { jsx as u } from "react/jsx-runtime";
+import { useMemo as r } from "react";
+import { T as o, g as l } from "./generate-tiles-DuagGD1d.js";
+import { c as m } from "./utils-CRiPKpXj.js";
+const k = [
+  [o.PieRand, o.PieRand],
+  [o.PieRand, o.PieRand]
+];
+function b({
+  pattern: e = k,
+  tileSize: h = 64,
+  tileClassName: c,
+  tileBgClassName: s,
+  renderChildren: d,
+  fit: i = "none",
+  ...g
+}) {
+  const t = r(
+    () => ({
+      width: e.reduce((n, v) => Math.max(n, v.length), 0) * h,
+      height: e.length * h
+    }),
+    [e, h]
+  ), a = r(() => {
+    const n = l(e, h, c);
+    return s && n.unshift(
+      /* @__PURE__ */ u(
+        "rect",
+        {
+          x: 0,
+          y: 0,
+          width: t.width,
+          height: t.height,
+          className: m("fill-black stroke-2 stroke-black", s)
+        },
+        "svg-mask-invert"
+      )
+    ), n;
+  }, [e, t, c, s, h]), w = r(() => {
+    switch (i) {
+      case "fill":
+        return t.width <= t.height ? "100%" : void 0;
+      case "width":
+        return "100%";
+      case "none":
+        return t.width;
+      default:
+        return;
+    }
+  }, [i, t]), f = r(() => {
+    switch (i) {
+      case "fill":
+        return t.height < t.width ? "100%" : void 0;
+      case "height":
+        return "100%";
+      case "none":
+        return t.height;
+      default:
+        return;
+    }
+  }, [i, t]);
+  return /* @__PURE__ */ u(
+    "svg",
+    {
+      width: w,
+      height: f,
+      viewBox: `0 0 ${t.width} ${t.height}`,
+      overflow: "visible",
+      ...g,
+      children: d ? d(a, t.width, t.height) : a
+    }
+  );
+}
+export {
+  b as I
+};

package/dist/icon-generator.d.ts

@@ -3,7 +3,7 @@ import { JSX as JSX_2 } from 'react/jsx-runtime';
 
 export declare function IconGenerator({ pattern, tileSize, tileClassName, tileBgClassName, renderChildren, fit, ...props }: IconGeneratorProps): JSX_2.Element;
 
-declare interface IconGeneratorProps extends Omit<React.ComponentProps<"svg">, "children" | "width" | "height" | "overflow"> {
+export declare interface IconGeneratorProps extends Omit<React.ComponentProps<"svg">, "children" | "width" | "height" | "overflow"> {
     pattern?: (TileShape | TileConfig)[][];
     tileSize?: number;
     tileClassName?: string;
@@ -12,13 +12,20 @@ declare interface IconGeneratorProps extends Omit<React.ComponentProps<"svg">, "
     renderChildren?: (paths: (JSX.Element | null)[], width: number, height: number) => React.ReactNode;
 }
 
-declare interface TileConfig {
+export declare interface MaskedImageGeneratorProps extends IconGeneratorProps {
+    src: string;
+    imageFit?: "cover" | "contain" | "fill";
+    imagePosition?: "top" | "center" | "bottom";
+    maskType?: "alpha" | "luminance";
+}
+
+export declare interface TileConfig {
     shape: TileShape;
     scale?: number;
     className?: string;
 }
 
-declare const TileShape: {
+export declare const TileShape: {
     readonly Blank: 0;
     readonly Rand: 1;
     readonly Mosaic: 2;
@@ -46,6 +53,6 @@ declare const TileShape: {
     readonly PieRand: 25;
 };
 
-declare type TileShape = (typeof TileShape)[keyof typeof TileShape];
+export declare type TileShape = (typeof TileShape)[keyof typeof TileShape];
 
 export { }