@feedmepos/mf-inventory-portal 0.0.5

package/dist/helper/number.d.ts

@@ -0,0 +1,27 @@
+import type { FCurrency, FdoDecimal, FdoDinero } from '@feedmepos/core/entity';
+export type AdjustmentAmount = FdoDecimal;
+export declare function zeroDinero(currency: FCurrency): FdoDinero;
+export declare function formatNumber(number: number, factor: number, precision: number): number;
+export declare function numberWithCommas(x: number): string;
+export declare function adjustmentAmountConvertPrecision(a: AdjustmentAmount, precision: number): AdjustmentAmount;
+export declare function adjustmentAmountSubtract(a: AdjustmentAmount, b: AdjustmentAmount): AdjustmentAmount;
+export declare function adjustmentAmountAdd(a: AdjustmentAmount, b: AdjustmentAmount): AdjustmentAmount;
+export declare function adjustmentAmountMultiply(a: AdjustmentAmount, multiplier: AdjustmentAmount): AdjustmentAmount;
+export declare function adjustmentAmountMultiplyDecimal(left: AdjustmentAmount, right: AdjustmentAmount): AdjustmentAmount;
+export declare function adjustmentAmountDivide(a: AdjustmentAmount, divisor: AdjustmentAmount): number;
+export declare function adjustmentAmountDivideDecimal(a: AdjustmentAmount, divisor: AdjustmentAmount): AdjustmentAmount;
+export declare function adjustmentAmountFormat(a: AdjustmentAmount, toPrecision?: boolean): string;
+export declare function adjustmentCurrencyFormat(a: FdoDinero, asSuffix?: boolean, precision?: number): string;
+export declare function adjustmentAmountAbs(a: AdjustmentAmount): AdjustmentAmount;
+export declare function getPrecision(a: number): number;
+export declare function toAdjustmentAmount(a: number): AdjustmentAmount;
+export declare function toAdjustmentWithPrecision(amt: string | number, precision?: number, allowNegative?: boolean): {
+    amount: number;
+    precision: number;
+};
+export declare function countDivisibleByTrailingZero(n: number): number;
+/**
+ * Returns the valid precision for a base unit or a converted measurement.
+ * Documentation at: https://www.notion.so/feedmepos/Precision-Handling-Logic-8e2211106b4a4a0f9fae8ee9c1e897da?pvs=4
+ */
+export declare function getAllowedPrecision(unit: FdoInventoryUnit, measurement?: FdoUnitMeasurement | null): number;

package/dist/helper/number.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helper/object.d.ts

@@ -0,0 +1,36 @@
+import type { Nullable } from './type';
+/** iterates keys in `schema` and creates an object with values at null */
+export declare function setNull<Schema extends Object>(schema: Schema): Nullable<Schema>;
+export declare function recursiveAssign(obj: any, paths: (string | number)[], value: any): void;
+export declare function recursivePush(obj: any, paths: (string | number)[], value: any): void;
+export declare function recursivePull(obj: any, paths: (string | number)[], index: number): void;
+export declare function recursiveGet(obj: any, paths: (string | number)[]): any;
+export declare function recursiveSet(obj: any, paths: (string | number)[], value: any): void;
+export declare function recursiveDelete(obj: any, paths: (string | number)[]): void;
+export declare function clone<T>(value: T, exceptKey?: string[]): T;
+export declare function walkObject<T>(fn: (value: T, key: string) => void, obj: {
+    [key: string]: T;
+}): void;
+export declare function arrayToObject<T extends {
+    [key: string]: any;
+}, K extends keyof T>(array: T[], idKey?: K): {
+    [key: string]: T;
+};
+export declare function objectToArray<T>(obj: {
+    [key: string]: T;
+}, idKey?: string): (T & {
+    _id: string;
+})[];
+export declare function circularReplacer(): (key: string, value: any) => any;
+export declare function group<T extends {
+    [key: string]: any;
+}, K extends keyof T>(list: T[], key: ((obj: T) => string) | K): {
+    [key: string]: T[];
+};
+export declare function pluck<T extends {
+    [key: string]: any;
+}, R>(items: T[], fn: (obj: T) => R): R[];
+/**
+ * Sort array if needed, order matters
+ */
+export declare function isDeepEql(a: any, b: any): boolean;

package/dist/helper/object.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helper/rules.d.ts

@@ -0,0 +1,22 @@
+import type { ValidationResult } from 'node_modules/@feedmepos/ui-library/dist/composables/useValidation';
+import { type AdjustmentAmount } from './number';
+import type { ISelectItem } from '@feedmepos/ui-library';
+export declare function Required(): (val: string) => true | "Required";
+export declare function isAdjustmentAmount(val: any): val is AdjustmentAmount;
+export declare function AtLeast(amount: number | AdjustmentAmount, message?: string | ((current: number) => string)): (val: any) => string | true;
+export declare function MoreThan(amount: number | AdjustmentAmount): (val: any, message?: string | ((current: number) => string) | undefined) => string | true;
+export declare function Between(lowerInclusive: Date, upperExclusive: Date): {
+    (val: string): ValidationResult;
+};
+export declare function Between(lowerInclusive: number, upperExclusive: number): {
+    (val: string): ValidationResult;
+};
+export declare function IsNumeric(): (maybeNumber: string) => true | "Must be a number";
+export declare function MaximumPrecision(precision: number): {
+    (val: string): ValidationResult;
+};
+export declare function MaximumPrecision(unit: FdoInventoryUnit, measurement?: FdoUnitMeasurement | null): {
+    (val: string): ValidationResult;
+};
+export declare function MaximumPrecisionLiteral(precision: number, message?: string | ((precision: number) => string)): (val: string) => string | true;
+export declare function Unique(pool: ISelectItem[], current?: string, message?: (item: ISelectItem) => string): (value: any) => string | true;

package/dist/helper/search.d.ts

@@ -0,0 +1,21 @@
+export interface SearchableLabelSublabel {
+    label?: string;
+    sublabel?: string;
+}
+export interface SearchableLabelSublabelNested extends SearchableLabelSublabel {
+    children?: SearchableLabelSublabelNested[];
+}
+export declare function createSearchFn(needle: string): <T extends SearchableLabelSublabelNested>(item: T) => T[];
+export declare function searchNested<T extends SearchableLabelSublabelNested>(needle: string, haystack: T[]): T[];
+export declare function searchLabel<T extends SearchableLabelSublabel>(needle: string, haystack: T[]): T[];
+export declare function searchMatch(needle: string, haystack: string[]): boolean;
+export interface HighlightableResultSegment {
+    segment: string;
+    isMatch: boolean;
+}
+export interface HighlightableResult {
+    label: string;
+    segments: HighlightableResultSegment[];
+    matched: boolean;
+}
+export declare function getHighlightableLetters(needle: string, haystack: string): HighlightableResult;

package/dist/helper/semver.d.ts

@@ -0,0 +1,20 @@
+export declare class SemVer {
+    readonly major: number;
+    readonly minor: number;
+    readonly patch: number;
+    readonly prerelease: string | null;
+    readonly build: string | null;
+    readonly original: string;
+    constructor(input: string);
+    static parse(input: string, throwOnError?: boolean): {
+        major: number;
+        minor: number;
+        patch: number;
+        prerelease: string;
+        build: string;
+        original: string;
+    } | null;
+    isGreaterThan(input: string | SemVer): boolean;
+    isGreaterThanOrEqual(input: string | SemVer): boolean;
+    isLesserThan(input: string | SemVer): boolean;
+}

package/dist/helper/semver.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helper/type.d.ts

@@ -0,0 +1,8 @@
+/**
+ * converts each properties in the object as `type` | null
+ *
+ * e.g. Nullable<{ name: string}> = { name: string | null }
+ */
+export type Nullable<T> = {
+    [K in keyof T]: T[K] extends Date ? Date | null : T[K] extends Object ? Nullable<T[K]> | null : T[K] extends Array<infer U> ? Array<Nullable<U>> | null : T[K] | null;
+};

package/dist/helper/url.d.ts

@@ -0,0 +1,7 @@
+export declare function isValidUrl(path: string): boolean;
+export declare function isValidPathname(path: string): boolean;
+export declare function extractPathFromBaseUrl(baseUrl: string): {
+    hostname: string;
+    pathname: string;
+};
+export declare function extendPathFromBaseUrl(path: string, baseUrl: string): string;

package/dist/helper/validate.d.ts

@@ -0,0 +1,70 @@
+export declare function validation(item: any): {
+    context: any;
+    error: string | null;
+    isRequired(msg?: string): {
+        context: any;
+        error: string | null;
+        isRequired(msg?: string): any;
+        isString(msg?: string): any;
+        toInt(): any;
+        isInteger(msg?: string): any;
+        min(size: number, msg?: string | undefined): any;
+        max(size: number, msg?: string | undefined): any;
+    };
+    isString(msg?: string): {
+        context: any;
+        error: string | null;
+        isRequired(msg?: string): any;
+        isString(msg?: string): any;
+        toInt(): any;
+        isInteger(msg?: string): any;
+        min(size: number, msg?: string | undefined): any;
+        max(size: number, msg?: string | undefined): any;
+    };
+    toInt(): {
+        context: any;
+        error: string | null;
+        isRequired(msg?: string): any;
+        isString(msg?: string): any;
+        toInt(): any;
+        isInteger(msg?: string): any;
+        min(size: number, msg?: string | undefined): any;
+        max(size: number, msg?: string | undefined): any;
+    };
+    isInteger(msg?: string): {
+        context: any;
+        error: string | null;
+        isRequired(msg?: string): any;
+        isString(msg?: string): any;
+        toInt(): any;
+        isInteger(msg?: string): any;
+        min(size: number, msg?: string | undefined): any;
+        max(size: number, msg?: string | undefined): any;
+    };
+    min(size: number, msg?: string | undefined): {
+        context: any;
+        error: string | null;
+        isRequired(msg?: string): any;
+        isString(msg?: string): any;
+        toInt(): any;
+        isInteger(msg?: string): any;
+        min(size: number, msg?: string | undefined): any;
+        max(size: number, msg?: string | undefined): any;
+    };
+    max(size: number, msg?: string | undefined): {
+        context: any;
+        error: string | null;
+        isRequired(msg?: string): any;
+        isString(msg?: string): any;
+        toInt(): any;
+        isInteger(msg?: string): any;
+        min(size: number, msg?: string | undefined): any;
+        max(size: number, msg?: string | undefined): any;
+    };
+};
+/** creates validation error dictionary */
+export declare function createErrorRefs<T extends Object>(obj: T): ErrorRef<T>;
+export type ErrorRef<T> = {
+    [K in keyof T]: T[K] extends string | number | boolean ? string | null : T[K] extends Array<infer U> ? ErrorRef<U>[] : ErrorRef<T[K]>;
+};
+export declare function hasError<T>(errorRef: ErrorRef<T>): boolean;

package/dist/helper/xlsx.util.d.ts

@@ -0,0 +1,8 @@
+import * as XLSX from 'xlsx';
+import type { WorkBook, WorkSheet } from 'xlsx';
+export declare function rowGenerator(range: string): Generator<number, void, unknown>;
+export declare function columnGenerator(range: string): Generator<string, void, unknown>;
+export declare function sheetToRowArray(sheet: WorkSheet): string[][];
+export declare function cellArrayToMapByHeaderRow<T = Record<string, string>>(items: string[][], usingHeader: string[]): T[];
+export declare function toSheet(data: any[][], header: string[], sheetName?: string): XLSX.WorkBook;
+export declare function downloadExcel(workbook: WorkBook, filename: string): void;

package/dist/helper/zod.d.ts

@@ -0,0 +1,21 @@
+import { type ZodArray, type ZodBoolean, type ZodNumber, type ZodObject, type ZodString, type ZodNullable, type ZodIssue, type ZodRawShape, type ZodTypeAny, type ZodOptional, type z, type ZodType, type ZodError, type ZodTypeDef } from 'zod';
+import type { Nullable } from './type';
+export declare function isZodType(item: any): item is ZodType<any, ZodTypeDef & {
+    typeName: string;
+}>;
+export declare function isZodNullable<T extends ZodTypeAny>(item: any): item is ZodNullable<T>;
+export declare function isZodOptional<T extends ZodTypeAny>(item: any): item is ZodOptional<T>;
+export declare function isZodString(item: any): item is ZodString;
+export declare function isZodBoolean(item: any): item is ZodBoolean;
+export declare function isZodNumber(item: any): item is ZodNumber;
+export declare function isZodArray(item: any): item is ZodArray<any>;
+export declare function isZodObject(item: any): item is ZodObject<any>;
+export declare function isZodError(item: any): item is ZodError;
+export declare function toReadableError(issue: ZodIssue): string;
+/**
+ * validation utils
+ * @deprecated to be replaced with setNullZodAny, TODO: check impact on current usage
+ */
+export declare function setNullZod<T extends ZodRawShape>(zodObject: ZodObject<T>, modelReference?: any): Nullable<z.infer<ZodObject<T>>>;
+export declare function setNullZodAny<T>(zodAny: ZodType<T>): Nullable<z.infer<typeof zodAny>>;
+export declare function normalizeNonString(obj: any, schema: ZodObject<any>): any;

package/dist/id-to-date-ReZIpUDw.js

@@ -0,0 +1,30 @@
+import { u as s, a as i } from "./xlsx-BljO4Lx2.js";
+function c(t, e) {
+  return e.map((n) => typeof n.selector == "function" ? n.selector(t) : `${t[n.selector]}`);
+}
+function u(t, e) {
+  const n = e.map((r) => r.name), a = t.map((r) => c(r, e));
+  return s.aoa_to_sheet([n, ...a]);
+}
+async function l(t, e) {
+  const n = s.book_new();
+  for (const a of t) {
+    const r = u(
+      a.data,
+      a.columns.map((o) => typeof o == "string" ? {
+        name: o,
+        selector: o
+      } : o)
+    );
+    s.book_append_sheet(n, r, a.name);
+  }
+  await i(n, e);
+}
+function p(t) {
+  let e = t.substring(t.indexOf("_") + 1);
+  return e.includes("_") && (e = e.substring(0, e.lastIndexOf("_"))), Number.isNaN(Date.parse(e)) ? null : new Date(e).toISOString();
+}
+export {
+  l as e,
+  p as i
+};