weasel-icons 0.1.0 → 0.2.0

package/dist/icons/leaf/leaf-rig.js

@@ -1,201 +0,0 @@
-import { behaviorBeat } from "../../shared/behavior-curves.js";
-/** Lucide-informed blade: one closed contour and one connected petiole/midrib. */
-export const leafStates = ['resting', 'growing', 'breezy', 'wilted'];
-// Corresponding cubic landmarks keep the same anatomy through all twelve edges.
-// Wilt is a bent petiole supporting a hanging blade, not a rotated healthy leaf.
-const REST = {
-    blade: [
-        [7, 17],
-        [4.1, 14.8],
-        [5.1, 10.2],
-        [8.3, 8.5],
-        [11.3, 6.9],
-        [15.8, 7.8],
-        [19, 3.2],
-        [20.7, 8.7],
-        [20.4, 13.6],
-        [16.7, 16.9],
-        [13.6, 19.7],
-        [9.2, 19.1],
-        [7, 17],
-    ],
-    stem: [
-        [3, 21],
-        [4, 19],
-        [5.8, 18],
-        [7, 17],
-        [9, 15],
-        [12, 12],
-        [15.5, 9],
-    ],
-};
-const GROW = {
-    blade: [
-        [7, 17],
-        [3.9, 14.3],
-        [4.6, 9.5],
-        [7.8, 7.5],
-        [10.8, 5.6],
-        [14.8, 6.7],
-        [17.5, 2.8],
-        [20.1, 7.2],
-        [20.7, 12.9],
-        [16.5, 16.6],
-        [13.5, 19.4],
-        [9.2, 19.2],
-        [7, 17],
-    ],
-    stem: [
-        [3, 21],
-        [4, 19],
-        [5.8, 18],
-        [7, 17],
-        [9.2, 14.8],
-        [12.3, 11.3],
-        [14.8, 8],
-    ],
-};
-const BREEZE = {
-    blade: [
-        [7, 17],
-        [4.7, 14.7],
-        [6.1, 10.5],
-        [9.2, 9],
-        [12.3, 7.5],
-        [16.7, 8.2],
-        [20.5, 5.5],
-        [21, 10.2],
-        [19.9, 14.4],
-        [16.6, 17],
-        [13.3, 19.6],
-        [9.2, 19],
-        [7, 17],
-    ],
-    stem: [
-        [3, 21],
-        [4, 19],
-        [5.8, 18],
-        [7, 17],
-        [9.3, 15.3],
-        [12.7, 12.5],
-        [16.5, 10.2],
-    ],
-};
-const WILT = {
-    blade: [
-        [9, 9],
-        [11.8, 6.8],
-        [16.1, 7.4],
-        [18, 10.6],
-        [19.6, 13.1],
-        [18.3, 16.2],
-        [18.7, 20],
-        [14.9, 19],
-        [11.8, 17.5],
-        [10.3, 14.8],
-        [9.1, 12.7],
-        [8.9, 10.7],
-        [9, 9],
-    ],
-    stem: [
-        [3, 21],
-        [3, 15.8],
-        [4.6, 9.8],
-        [9, 9],
-        [12.1, 8.4],
-        [15.5, 11.7],
-        [16.3, 15.6],
-    ],
-};
-const POSES = [REST, GROW, BREEZE, WILT];
-export const LEAF_SCENE_SECONDS = 5.2;
-export const leafBehaviors = {
-    resting: ['a quiet tip nod', 'catch a little light', 'soft blade flex'],
-    growing: ['open toward the light', 'stretch, then unfurl the tip', 'a small proud lift'],
-    breezy: [
-        'lean into a passing gust',
-        'tip flutters after the blade',
-        'longer breeze, soft recovery',
-    ],
-    wilted: ['petiole gives a little', 'edges curl inward', 'a tired tip settles'],
-};
-const n = (v) => Number(v.toFixed(5));
-const path = (points, closed) => points.map((p, i) => `${i === 0 ? 'M' : i % 3 === 1 ? 'C' : ''}${n(p[0])} ${n(p[1])}`).join(' ') +
-    (closed ? ' Z' : '');
-export function sampleLeaf(weights, time = 0, alive = 0) {
-    const [resting, growing, breezy, wilted] = weights;
-    const life = Math.max(0, Math.min(1, alive));
-    const t = Math.max(0, time) % LEAF_SCENE_SECONDS;
-    const scene = Math.floor(Math.max(0, time) / LEAF_SCENE_SECONDS) % 3;
-    const beat = (start, rise = 0.6, hold = 0.15, fall = 1) => Math.max(0, behaviorBeat(t, start, rise, hold, fall));
-    const a = beat(0.25), b = beat(1.7, 0.45, 0.12, 0.9), long = beat(0.35, 1.05, 0.35, 1.4);
-    // A continuous low-amplitude flex supports the phrases; the root never drifts.
-    // Delayed tip curvature makes this a flexible blade, not a rigid pendulum.
-    let bend = (resting * 0.16 + growing * 0.18) * Math.sin(time * 1.65) +
-        breezy * (1.05 * Math.sin(time * 2.6) + 0.2 * Math.sin(time * 4.1)) +
-        wilted * 0.1 * Math.sin(time * 1.4);
-    let curl = breezy * (0.38 * Math.sin(time * 2.6 - 0.55) + 0.12 * Math.sin(time * 4.1 - 0.8));
-    let dip = wilted * 0.1 * Math.sin(time * 1.4), lift = 0, spread = 0;
-    let glint = 0;
-    if (scene === 0) {
-        curl += resting * a * 0.65;
-        lift += growing * a * 0.65;
-        spread += growing * a * 0.075;
-        bend += breezy * a * 0.48;
-        curl += breezy * b * 0.26;
-        dip += wilted * a * 0.58;
-    }
-    else if (scene === 1) {
-        bend -= resting * a * 0.2;
-        glint = (resting * 0.2 + growing * 0.58) * b;
-        lift += growing * a * 0.4;
-        curl -= growing * b * 0.55;
-        curl += breezy * (a * 0.3 - b * 0.36);
-        bend += breezy * a * 0.24;
-        spread -= wilted * a * 0.12;
-        curl += wilted * b * 0.35;
-    }
-    else {
-        spread += resting * long * 0.018;
-        lift += growing * long * 0.75;
-        spread += growing * long * 0.055;
-        bend += breezy * long * 0.6;
-        curl += breezy * long * 0.3;
-        dip += wilted * long * 0.35;
-        curl += wilted * long * 0.55;
-    }
-    const deform = ([x, y], part, index) => {
-        const u = (x - 3) / 18, v = (21 - y) / 18;
-        // The blade base, its duplicate closing point and the midrib joint share
-        // precisely one deformation. Only the blade's free edges can spread.
-        const freeEdge = part === 'blade' && ![0, 6, 12].includes(index);
-        const center = 3 + (21 - y) * 0.8;
-        return [
-            x + life * (bend * v * v + (freeEdge ? (x - center) * spread : 0)),
-            y + life * (dip * u * u - lift * v + curl * u * u * u),
-        ];
-    };
-    const blend = (part) => POSES[0][part]
-        .map((_, j) => [
-        POSES.reduce((v, p, i) => v + p[part][j][0] * weights[i], 0),
-        POSES.reduce((v, p, i) => v + p[part][j][1] * weights[i], 0),
-    ])
-        .map((p, j) => deform(p, part, j));
-    const blade = blend('blade'), stem = blend('stem');
-    const wind = [0, 1].map((i) => {
-        const phase = (((time * 0.55 + i * 0.45) % 1) + 1) % 1;
-        return {
-            opacity: life * breezy ** 2 * 0.42 * Math.sin(Math.PI * phase) ** 2,
-            offset: life > 0 && breezy > 0 ? life * breezy * (3 - phase * 9) : 0,
-        };
-    });
-    return {
-        blade: path(blade, true),
-        stem: path(stem, false),
-        bladePoints: blade,
-        stemPoints: stem,
-        tint: growing * (0.09 + life * a * 0.025),
-        wind,
-        glint: life * glint,
-    };
-}