@zuplo/cli 7.4.5 → 7.4.7

package/node_modules/@posthog/core/dist/featureFlagLocalEvaluation.mjs

@@ -0,0 +1,294 @@
+import { parsePayload } from "./featureFlagUtils.mjs";
+const NULL_VALUES_ALLOWED_OPERATORS = [
+    'is_not',
+    'is_set'
+];
+const LONG_SCALE = 0xfffffffffffffff;
+class InconclusiveMatchError extends Error {
+    constructor(message){
+        super(message);
+        this.name = this.constructor.name;
+        Object.setPrototypeOf(this, InconclusiveMatchError.prototype);
+    }
+}
+function isValidRegex(regex) {
+    try {
+        new RegExp(regex);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function parseSemverNumericIdentifier(part, raw, parsingPolicy) {
+    if (!/^\d+$/.test(part) || 'strict' === parsingPolicy && part.length > 1 && '0' === part[0]) throw new InconclusiveMatchError(`Invalid semver: ${raw}`);
+    return parseInt(part, 10);
+}
+function parseFeatureFlagSemver(value, parsingPolicy = 'strict') {
+    const text = String(value).trim().replace(/^[vV]/, '');
+    const baseVersion = text.split('-')[0].split('+')[0];
+    if (!baseVersion || baseVersion.startsWith('.')) throw new InconclusiveMatchError(`Invalid semver: ${value}`);
+    const parts = baseVersion.split('.');
+    const parsePart = (part)=>{
+        if (void 0 === part || '' === part) return 0;
+        return parseSemverNumericIdentifier(part, value, parsingPolicy);
+    };
+    return [
+        parsePart(parts[0]),
+        parsePart(parts[1]),
+        parsePart(parts[2])
+    ];
+}
+function compareSemverTuples(a, b) {
+    for(let i = 0; i < 3; i++){
+        if (a[i] < b[i]) return -1;
+        if (a[i] > b[i]) return 1;
+    }
+    return 0;
+}
+function computeTildeBounds(value, parsingPolicy) {
+    const parsed = parseFeatureFlagSemver(value, parsingPolicy);
+    return {
+        lower: [
+            parsed[0],
+            parsed[1],
+            parsed[2]
+        ],
+        upper: [
+            parsed[0],
+            parsed[1] + 1,
+            0
+        ]
+    };
+}
+function computeCaretBounds(value, parsingPolicy) {
+    const [major, minor, patch] = parseFeatureFlagSemver(value, parsingPolicy);
+    const lower = [
+        major,
+        minor,
+        patch
+    ];
+    let upper;
+    upper = major > 0 ? [
+        major + 1,
+        0,
+        0
+    ] : minor > 0 ? [
+        0,
+        minor + 1,
+        0
+    ] : [
+        0,
+        0,
+        patch + 1
+    ];
+    return {
+        lower,
+        upper
+    };
+}
+function computeWildcardBounds(value, parsingPolicy) {
+    const text = String(value).trim().replace(/^[vV]/, '');
+    const cleanedText = text.replace(/\.\*$/, '').replace(/\*$/, '');
+    if (!cleanedText) throw new InconclusiveMatchError(`Invalid wildcard semver: ${value}`);
+    const parts = cleanedText.split('.');
+    const parseWildcardPart = (part)=>{
+        if ('legacy-permissive' === parsingPolicy) {
+            const parsed = parseInt(part, 10);
+            if (!isNaN(parsed)) return parsed;
+        } else try {
+            return parseSemverNumericIdentifier(part, value, parsingPolicy);
+        } catch  {}
+        throw new InconclusiveMatchError(`Invalid wildcard semver: ${value}`);
+    };
+    const major = parseWildcardPart(parts[0]);
+    if (1 === parts.length) return {
+        lower: [
+            major,
+            0,
+            0
+        ],
+        upper: [
+            major + 1,
+            0,
+            0
+        ]
+    };
+    const minor = parseWildcardPart(parts[1]);
+    return {
+        lower: [
+            major,
+            minor,
+            0
+        ],
+        upper: [
+            major,
+            minor + 1,
+            0
+        ]
+    };
+}
+function convertToDateTime(value) {
+    if (value instanceof Date) return value;
+    if ('string' == typeof value || 'number' == typeof value) {
+        const date = new Date(value);
+        if (!isNaN(date.valueOf())) return date;
+        throw new InconclusiveMatchError(`${value} is in an invalid date format`);
+    }
+    throw new InconclusiveMatchError(`The date provided ${value} must be a string, number, or date object`);
+}
+function relativeDateParseForFeatureFlagMatching(value) {
+    const regex = /^-?(?<number>[0-9]+)(?<interval>[a-z])$/;
+    const match = value.match(regex);
+    const parsedDt = new Date(new Date().toISOString());
+    if (!match || !match.groups) return null;
+    const number = parseInt(match.groups['number']);
+    if (number >= 10000) return null;
+    const interval = match.groups['interval'];
+    if ('h' === interval) parsedDt.setUTCHours(parsedDt.getUTCHours() - number);
+    else if ('d' === interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - number);
+    else if ('w' === interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - 7 * number);
+    else if ('m' === interval) parsedDt.setUTCMonth(parsedDt.getUTCMonth() - number);
+    else {
+        if ('y' !== interval) return null;
+        parsedDt.setUTCFullYear(parsedDt.getUTCFullYear() - number);
+    }
+    return parsedDt;
+}
+function matchFeatureFlagProperty(property, propertyValues, options = {}) {
+    const key = property.key;
+    const value = property.value;
+    const operator = property.operator || 'exact';
+    const parsingPolicy = options.semverParsingPolicy ?? 'strict';
+    if (key in propertyValues) {
+        if ('is_not_set' === operator) return false;
+    } else {
+        if ('is_not_set' === operator) return true;
+        throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`);
+    }
+    const overrideValue = propertyValues[key];
+    if (null == overrideValue && !NULL_VALUES_ALLOWED_OPERATORS.includes(operator)) {
+        options.warnFunction?.(`Property ${key} cannot have a value of null/undefined with the ${operator} operator`);
+        return false;
+    }
+    const computeExactMatch = (target, actual)=>{
+        if (Array.isArray(target)) return target.map((item)=>String(item).toLowerCase()).includes(String(actual).toLowerCase());
+        return String(target).toLowerCase() === String(actual).toLowerCase();
+    };
+    const compare = (lhs, rhs, comparisonOperator)=>{
+        if ('gt' === comparisonOperator) return lhs > rhs;
+        if ('gte' === comparisonOperator) return lhs >= rhs;
+        if ('lt' === comparisonOperator) return lhs < rhs;
+        if ('lte' === comparisonOperator) return lhs <= rhs;
+        throw new Error(`Invalid operator: ${comparisonOperator}`);
+    };
+    switch(operator){
+        case 'exact':
+            return computeExactMatch(value, overrideValue);
+        case 'is_not':
+            return !computeExactMatch(value, overrideValue);
+        case 'is_set':
+            return key in propertyValues;
+        case 'icontains':
+            return String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
+        case 'not_icontains':
+            return !String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
+        case 'starts_with':
+            return String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase());
+        case 'not_starts_with':
+            return !String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase());
+        case 'ends_with':
+            return String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase());
+        case 'not_ends_with':
+            return !String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase());
+        case 'regex':
+            return isValidRegex(String(value)) && null !== String(overrideValue).match(String(value));
+        case 'not_regex':
+            return isValidRegex(String(value)) && null === String(overrideValue).match(String(value));
+        case 'gt':
+        case 'gte':
+        case 'lt':
+        case 'lte':
+            {
+                const parsedValue = 'number' == typeof value ? value : parseFloat(String(value));
+                const parsedOverride = 'number' == typeof overrideValue ? overrideValue : null != overrideValue ? parseFloat(String(overrideValue)) : NaN;
+                if (Number.isFinite(parsedValue) && Number.isFinite(parsedOverride)) return compare(parsedOverride, parsedValue, operator);
+                return compare(String(overrideValue), String(value), operator);
+            }
+        case 'is_date_after':
+        case 'is_date_before':
+            {
+                if ('boolean' == typeof value) throw new InconclusiveMatchError('Date operations cannot be performed on boolean values');
+                let parsedDate = relativeDateParseForFeatureFlagMatching(String(value));
+                if (null == parsedDate) parsedDate = convertToDateTime(value);
+                const overrideDate = convertToDateTime(overrideValue);
+                return 'is_date_before' === operator ? overrideDate < parsedDate : overrideDate > parsedDate;
+            }
+        case 'semver_eq':
+            return 0 === compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy));
+        case 'semver_neq':
+            return 0 !== compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy));
+        case 'semver_gt':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) > 0;
+        case 'semver_gte':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) >= 0;
+        case 'semver_lt':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) < 0;
+        case 'semver_lte':
+            return compareSemverTuples(parseFeatureFlagSemver(String(overrideValue), parsingPolicy), parseFeatureFlagSemver(String(value), parsingPolicy)) <= 0;
+        case 'semver_tilde':
+            {
+                const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy);
+                const { lower, upper } = computeTildeBounds(String(value), parsingPolicy);
+                return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+            }
+        case 'semver_caret':
+            {
+                const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy);
+                const { lower, upper } = computeCaretBounds(String(value), parsingPolicy);
+                return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+            }
+        case 'semver_wildcard':
+            {
+                const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy);
+                const { lower, upper } = computeWildcardBounds(String(value), parsingPolicy);
+                return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+            }
+        default:
+            throw new InconclusiveMatchError(`Unknown operator: ${operator}`);
+    }
+}
+async function hashSHA1(text) {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) throw new Error('SubtleCrypto API not available');
+    const hashBuffer = await subtle.digest('SHA-1', new TextEncoder().encode(text));
+    return Array.from(new Uint8Array(hashBuffer)).map((byte)=>byte.toString(16).padStart(2, '0')).join('');
+}
+async function getFeatureFlagHash(key, bucketingValue, salt = '') {
+    const hashString = await hashSHA1(`${key}.${bucketingValue}${salt}`);
+    return parseInt(hashString.slice(0, 15), 16) / LONG_SCALE;
+}
+function getFeatureFlagVariantLookupTable(variants) {
+    const table = [];
+    let valueMin = 0;
+    for (const variant of variants){
+        const valueMax = valueMin + variant.rollout_percentage / 100.0;
+        table.push({
+            valueMin,
+            valueMax,
+            key: variant.key
+        });
+        valueMin = valueMax;
+    }
+    return table;
+}
+async function getFeatureFlagVariant(key, bucketingValue, variants) {
+    const hashValue = await getFeatureFlagHash(key, bucketingValue, 'variant');
+    return getFeatureFlagVariantLookupTable(variants).find((variant)=>hashValue >= variant.valueMin && hashValue < variant.valueMax)?.key;
+}
+function resolveFeatureFlagPayload(payloads, flagValue) {
+    if (false === flagValue || null == flagValue || !payloads) return null;
+    const payloadKey = 'boolean' == typeof flagValue ? flagValue.toString() : flagValue;
+    const payload = payloads[payloadKey] || null;
+    return null == payload ? null : parsePayload(payload);
+}
+export { InconclusiveMatchError, getFeatureFlagHash, getFeatureFlagVariant, getFeatureFlagVariantLookupTable, hashSHA1, matchFeatureFlagProperty, parseFeatureFlagSemver, relativeDateParseForFeatureFlagMatching, resolveFeatureFlagPayload };

package/node_modules/@posthog/core/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { getFeatureFlagValue, getEnabledFromValue, getVariantFromValue, parsePayload, flagDetailsToResults, MINIMAL_FLAG_CALLED_EVENT_CAMPAIGN_PROPERTIES, minimizeFlagCalledEventProperties, } from './featureFlagUtils';
+export { getFeatureFlagHash, getFeatureFlagVariant, getFeatureFlagVariantLookupTable, hashSHA1, InconclusiveMatchError, matchFeatureFlagProperty, parseFeatureFlagSemver, relativeDateParseForFeatureFlagMatching, resolveFeatureFlagPayload, } from './featureFlagLocalEvaluation';
+export type { FeatureFlagProperty, FeatureFlagPropertyValue, FeatureFlagSemverParsingPolicy, FeatureFlagVariant, FeatureFlagVariantLookupEntry, MatchFeatureFlagPropertyOptions, } from './featureFlagLocalEvaluation';
 export { gzipCompress, isGzipData, isGzipRequest, isGzipSupported, isNativeAsyncGzipError, isNativeAsyncGzipReadError, } from './gzip';
 export * from './utils';
 export * as ErrorTracking from './error-tracking';

package/node_modules/@posthog/core/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,YAAY,EACZ,oBAAoB,EACpB,6CAA6C,EAC7C,iCAAiC,GAClC,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,YAAY,EACZ,UAAU,EACV,aAAa,EACb,eAAe,EACf,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,QAAQ,CAAA;AACf,cAAc,SAAS,CAAA;AACvB,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAA;AACjD,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,GACnB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AACpC,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,cAAc,CAAA;AAIrB,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAGzG,YAAY,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAGhE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,EACL,cAAc,EACd,uBAAuB,EACvB,8BAA8B,EAC9B,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,WAAW,CAAA;AAClB,YAAY,EACV,WAAW,EACX,oBAAoB,EACpB,4BAA4B,EAC5B,uBAAuB,GACxB,MAAM,WAAW,CAAA;AAElB,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,oBAAoB,EACpB,YAAY,EACZ,UAAU,EACV,OAAO,EACP,aAAa,GACd,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,YAAY,EACZ,oBAAoB,EACpB,6CAA6C,EAC7C,iCAAiC,GAClC,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,gCAAgC,EAChC,QAAQ,EACR,sBAAsB,EACtB,wBAAwB,EACxB,sBAAsB,EACtB,uCAAuC,EACvC,yBAAyB,GAC1B,MAAM,8BAA8B,CAAA;AACrC,YAAY,EACV,mBAAmB,EACnB,wBAAwB,EACxB,8BAA8B,EAC9B,kBAAkB,EAClB,6BAA6B,EAC7B,+BAA+B,GAChC,MAAM,8BAA8B,CAAA;AACrC,OAAO,EACL,YAAY,EACZ,UAAU,EACV,aAAa,EACb,eAAe,EACf,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,QAAQ,CAAA;AACf,cAAc,SAAS,CAAA;AACvB,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAA;AACjD,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,kBAAkB,GACnB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AACpC,YAAY,EACV,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,iBAAiB,EACjB,yBAAyB,GAC1B,MAAM,cAAc,CAAA;AAIrB,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAGzG,YAAY,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAGhE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC1D,OAAO,EACL,cAAc,EACd,uBAAuB,EACvB,8BAA8B,EAC9B,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,WAAW,CAAA;AAClB,YAAY,EACV,WAAW,EACX,oBAAoB,EACpB,4BAA4B,EAC5B,uBAAuB,GACxB,MAAM,WAAW,CAAA;AAElB,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,oBAAoB,EACpB,YAAY,EACZ,UAAU,EACV,OAAO,EACP,aAAa,GACd,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,cAAc,UAAU,CAAA;AACxB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,0BAA0B,CAAA;AACxC,cAAc,mBAAmB,CAAA;AACjC,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA"}