@perses-dev/core 0.0.0-snapshot-scatter-chart-embed-8efdfab → 0.0.0-snapshot-explorer-plugin-c4a7621

package/dist/cjs/schema/secret.js

@@ -0,0 +1,174 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    globalSecretSchema: function() {
+        return globalSecretSchema;
+    },
+    secretSchema: function() {
+        return secretSchema;
+    },
+    secretSpecSchema: function() {
+        return secretSpecSchema;
+    },
+    secretsEditorSchema: function() {
+        return secretsEditorSchema;
+    }
+});
+const _zod = require("zod");
+const _metadata = require("./metadata");
+const secretSpecSchema = _zod.z.object({
+    basicAuth: _zod.z.object({
+        username: _zod.z.string().min(1),
+        password: _zod.z.string().optional(),
+        passwordFile: _zod.z.string().optional()
+    }).superRefine((val, ctx)=>{
+        if (val.password && val.password.length > 0 && val.passwordFile && val.passwordFile.length > 0) {
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'password'
+                ]
+            });
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'passwordFile'
+                ]
+            });
+        }
+    }).optional(),
+    authorization: _zod.z.object({
+        type: _zod.z.string().optional(),
+        credentials: _zod.z.string().optional(),
+        credentialsFile: _zod.z.string().optional()
+    }).superRefine((val, ctx)=>{
+        if (val.credentials && val.credentials.length > 0 && val.credentialsFile && val.credentialsFile.length > 0) {
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'credentials'
+                ]
+            });
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'credentialsFile'
+                ]
+            });
+        }
+    }).optional(),
+    tlsConfig: _zod.z.object({
+        ca: _zod.z.string().optional(),
+        cert: _zod.z.string().optional(),
+        key: _zod.z.string().optional(),
+        caFile: _zod.z.string().optional(),
+        certFile: _zod.z.string().optional(),
+        keyFile: _zod.z.string().optional(),
+        serverName: _zod.z.string().optional(),
+        insecureSkipVerify: _zod.z.boolean()
+    }).superRefine((val, ctx)=>{
+        if (val.ca && val.ca.length > 0 && val.caFile && val.caFile.length > 0) {
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'ca'
+                ]
+            });
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'caFile'
+                ]
+            });
+        }
+        if (val.cert && val.cert.length > 0 && val.certFile && val.certFile.length > 0) {
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'cert'
+                ]
+            });
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'certFile'
+                ]
+            });
+        }
+        if (val.key && val.key.length > 0 && val.keyFile && val.keyFile.length > 0) {
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'key'
+                ]
+            });
+            ctx.addIssue({
+                code: _zod.z.ZodIssueCode.custom,
+                message: 'Only one of the fields must be defined',
+                path: [
+                    'keyFile'
+                ]
+            });
+        }
+    }).optional()
+}).superRefine((val, ctx)=>{
+    if (val.basicAuth && val.authorization) {
+        ctx.addIssue({
+            code: _zod.z.ZodIssueCode.custom,
+            message: 'Only one of the fields must be defined',
+            path: [
+                'basicAuth'
+            ]
+        });
+        ctx.addIssue({
+            code: _zod.z.ZodIssueCode.custom,
+            message: 'Only one of the fields must be defined',
+            path: [
+                'authorization'
+            ]
+        });
+    }
+});
+const secretSchema = _zod.z.object({
+    kind: _zod.z.literal('Secret'),
+    metadata: _metadata.projectMetadataSchema,
+    spec: secretSpecSchema
+});
+const globalSecretSchema = _zod.z.object({
+    kind: _zod.z.literal('GlobalSecret'),
+    metadata: _metadata.metadataSchema,
+    spec: secretSpecSchema
+});
+const secretsEditorSchema = _zod.z.discriminatedUnion('kind', [
+    secretSchema,
+    globalSecretSchema
+]);

package/dist/cjs/schema/user.js

@@ -0,0 +1,57 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    nativeProviderSchema: function() {
+        return nativeProviderSchema;
+    },
+    oauthProvidersSchema: function() {
+        return oauthProvidersSchema;
+    },
+    userSchema: function() {
+        return userSchema;
+    },
+    userSpecSchema: function() {
+        return userSpecSchema;
+    }
+});
+const _zod = require("zod");
+const _metadata = require("./metadata");
+const nativeProviderSchema = _zod.z.object({
+    password: _zod.z.string().optional()
+});
+const oauthProvidersSchema = _zod.z.object({
+    issuer: _zod.z.string().optional(),
+    email: _zod.z.string().optional(),
+    subject: _zod.z.string().optional()
+});
+const userSpecSchema = _zod.z.object({
+    firstName: _zod.z.string().optional(),
+    lastName: _zod.z.string().optional(),
+    nativeProvider: nativeProviderSchema.optional(),
+    oauthProviders: _zod.z.array(oauthProvidersSchema).optional()
+});
+const userSchema = _zod.z.object({
+    kind: _zod.z.literal('User'),
+    metadata: _metadata.metadataSchema,
+    spec: userSpecSchema
+});

package/dist/cjs/schema/variable.js

@@ -0,0 +1,171 @@
+// Copyright 2023 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    buildVariableDefinitionSchema: function() {
+        return buildVariableDefinitionSchema;
+    },
+    buildVariableListSchema: function() {
+        return buildVariableListSchema;
+    },
+    buildVariableListSpecSchema: function() {
+        return buildVariableListSpecSchema;
+    },
+    buildVariableSpecSchema: function() {
+        return buildVariableSpecSchema;
+    },
+    globalVariableSchema: function() {
+        return globalVariableSchema;
+    },
+    variableDefinitionSchema: function() {
+        return variableDefinitionSchema;
+    },
+    variableDisplaySchema: function() {
+        return variableDisplaySchema;
+    },
+    variableListSchema: function() {
+        return variableListSchema;
+    },
+    variableListSpecSchema: function() {
+        return variableListSpecSchema;
+    },
+    variableSchema: function() {
+        return variableSchema;
+    },
+    variableSpecSchema: function() {
+        return variableSpecSchema;
+    },
+    variableTextSchema: function() {
+        return variableTextSchema;
+    },
+    variableTextSpecSchema: function() {
+        return variableTextSpecSchema;
+    },
+    variablesSchema: function() {
+        return variablesSchema;
+    }
+});
+const _zod = require("zod");
+const _metadata = require("./metadata");
+const _plugin = require("./plugin");
+const variableDisplaySchema = _zod.z.object({
+    name: _zod.z.string().optional(),
+    description: _zod.z.string().optional(),
+    hidden: _zod.z.boolean().optional()
+});
+const variableListSpecSchema = _zod.z.object({
+    name: _zod.z.string().min(1),
+    display: variableDisplaySchema.optional(),
+    defaultValue: _zod.z.string().or(_zod.z.array(_zod.z.string())).optional(),
+    allowAllValue: _zod.z.boolean(),
+    allowMultiple: _zod.z.boolean(),
+    customAllValue: _zod.z.string().optional(),
+    capturingRegexp: _zod.z.string().optional(),
+    sort: _zod.z.enum([
+        'none',
+        'alphabetical-asc',
+        'alphabetical-desc',
+        'numerical-asc',
+        'numerical-desc',
+        'alphabetical-ci-asc',
+        'alphabetical-ci-desc'
+    ]).optional(),
+    plugin: _plugin.pluginSchema
+});
+function buildVariableListSpecSchema(pluginSchema) {
+    return _zod.z.object({
+        name: _zod.z.string().min(1),
+        display: variableDisplaySchema.optional(),
+        defaultValue: _zod.z.string().or(_zod.z.array(_zod.z.string())).optional(),
+        allowAllValue: _zod.z.boolean(),
+        allowMultiple: _zod.z.boolean(),
+        customAllValue: _zod.z.string().optional(),
+        capturingRegexp: _zod.z.string().optional(),
+        sort: _zod.z.enum([
+            'none',
+            'alphabetical-asc',
+            'alphabetical-desc',
+            'numerical-asc',
+            'numerical-desc',
+            'alphabetical-ci-asc',
+            'alphabetical-ci-desc'
+        ]).optional(),
+        plugin: pluginSchema
+    });
+}
+const variableListSchema = _zod.z.object({
+    kind: _zod.z.literal('ListVariable'),
+    spec: variableListSpecSchema
+});
+function buildVariableListSchema(pluginSchema) {
+    return _zod.z.object({
+        kind: _zod.z.literal('ListVariable'),
+        spec: buildVariableListSpecSchema(pluginSchema)
+    });
+}
+const variableTextSpecSchema = _zod.z.object({
+    name: _zod.z.string().min(1),
+    display: variableDisplaySchema.optional(),
+    value: _zod.z.string(),
+    constant: _zod.z.boolean().optional()
+});
+const variableTextSchema = _zod.z.object({
+    kind: _zod.z.literal('TextVariable'),
+    spec: variableTextSpecSchema
+});
+const variableSpecSchema = _zod.z.discriminatedUnion('kind', [
+    variableTextSchema,
+    variableListSchema
+]);
+function buildVariableSpecSchema(pluginSchema) {
+    return _zod.z.union([
+        variableTextSchema,
+        buildVariableListSchema(pluginSchema)
+    ]);
+}
+const variableSchema = _zod.z.object({
+    kind: _zod.z.literal('Variable'),
+    metadata: _metadata.projectMetadataSchema,
+    spec: variableSpecSchema
+});
+const globalVariableSchema = _zod.z.object({
+    kind: _zod.z.literal('GlobalVariable'),
+    metadata: _metadata.projectMetadataSchema,
+    spec: variableSpecSchema
+});
+const variablesSchema = _zod.z.discriminatedUnion('kind', [
+    variableSchema,
+    globalVariableSchema
+]);
+const variableDefinitionSchema = variableSpecSchema;
+function buildVariableDefinitionSchema(pluginSchema) {
+    return _zod.z.discriminatedUnion('kind', [
+        _zod.z.object({
+            kind: _zod.z.literal('ListVariable'),
+            spec: buildVariableListSpecSchema(pluginSchema)
+        }),
+        _zod.z.object({
+            kind: _zod.z.literal('TextVariable'),
+            spec: variableTextSpecSchema
+        })
+    ]);
+}

package/dist/cjs/utils/fetch.js

@@ -23,41 +23,35 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    fetch: function() {
-        return fetch;
-    },
-    fetchJson: function() {
-        return fetchJson;
-    },
     FetchError: function() {
         return FetchError;
     },
     UserFriendlyError: function() {
         return UserFriendlyError;
+    },
+    fetch: function() {
+        return fetch;
+    },
+    fetchJson: function() {
+        return fetchJson;
     }
 });
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
 async function fetch(...args) {
     const response = await global.fetch(...args);
     if (response.ok === false) {
-        const json = await response.json();
-        if (json.error) {
-            throw new UserFriendlyError(json.error, response.status);
+        const contentType = response.headers.get('content-type');
+        if (contentType?.includes('application/json')) {
+            const json = await response.json();
+            if (json.error) {
+                throw new UserFriendlyError(json.error, response.status);
+            }
+            if (json.message) {
+                throw new UserFriendlyError(json.message, response.status);
+            }
         }
-        if (json.message) {
-            throw new UserFriendlyError(json.message, response.status);
+        const text = await response.text();
+        if (text) {
+            throw new UserFriendlyError(text, response.status);
         }
         throw new FetchError(response);
     }
@@ -69,17 +63,17 @@ async function fetchJson(...args) {
     return json;
 }
 class FetchError extends Error {
+    status;
     constructor(response){
         super(`${response.status} ${response.statusText}`);
-        _define_property(this, "status", void 0);
         this.status = response.status;
         Object.setPrototypeOf(this, FetchError.prototype);
     }
 }
 class UserFriendlyError extends Error {
+    status;
     constructor(message, status){
         super(message);
-        _define_property(this, "status", void 0);
         this.status = status;
         Object.setPrototypeOf(this, UserFriendlyError.prototype);
     }

package/dist/cjs/utils/index.js

@@ -21,7 +21,10 @@ _export_star(require("./memo"), exports);
 _export_star(require("./panel-refs"), exports);
 _export_star(require("./text"), exports);
 _export_star(require("./time-series-data"), exports);
+_export_star(require("./transform-data"), exports);
+_export_star(require("./value-mapping"), exports);
 _export_star(require("./types"), exports);
+_export_star(require("./regexp"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
         if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {

package/dist/cjs/utils/mathjs.js

@@ -22,6 +22,6 @@ Object.defineProperty(exports, "gcd", {
 });
 const _mathjs = require("mathjs");
 // This ensures we get a minimal mathjs bundle for just what we need (see https://mathjs.org/docs/custom_bundling.html)
-const { gcd  } = (0, _mathjs.create)({
+const { gcd } = (0, _mathjs.create)({
     gcdDependencies: _mathjs.gcdDependencies
 });

package/dist/cjs/utils/memo.js

@@ -21,11 +21,11 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    useMemoized: function() {
-        return useMemoized;
-    },
     useDeepMemo: function() {
         return useDeepMemo;
+    },
+    useMemoized: function() {
+        return useMemoized;
     }
 });
 const _react = require("react");
@@ -39,8 +39,7 @@ function useMemoized(factory, deps) {
     const ref = (0, _react.useRef)();
     let areEqual = true;
     for(let i = 0; i < deps.length; i++){
-        var _ref_current;
-        if (((_ref_current = ref.current) === null || _ref_current === void 0 ? void 0 : _ref_current.deps[i]) !== deps[i]) {
+        if (ref.current?.deps[i] !== deps[i]) {
             areEqual = false;
             break;
         }

package/dist/cjs/utils/panel-refs.js

@@ -21,14 +21,14 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    resolvePanelRef: function() {
-        return resolvePanelRef;
+    createPanelRef: function() {
+        return createPanelRef;
     },
     getPanelKeyFromRef: function() {
         return getPanelKeyFromRef;
     },
-    createPanelRef: function() {
-        return createPanelRef;
+    resolvePanelRef: function() {
+        return resolvePanelRef;
     }
 });
 function resolvePanelRef(spec, panelRef) {

package/dist/cjs/utils/regexp.js

@@ -0,0 +1,54 @@
+// Copyright 2024 The Perses Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/**
+ * Checks if a string is a regex pattern.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createRegexFromString: function() {
+        return createRegexFromString;
+    },
+    isRegexPattern: function() {
+        return isRegexPattern;
+    }
+});
+function isRegexPattern(input) {
+    return Boolean(input?.startsWith('/'));
+}
+function createRegexFromString(input) {
+    if (!input) {
+        throw new Error('Input string cannot be empty');
+    }
+    if (!isRegexPattern(input)) {
+        return new RegExp(`^${input}$`);
+    }
+    const regexPattern = /^\/(.+)\/([gimy]*)$/;
+    const matches = input.match(regexPattern);
+    if (!matches) {
+        throw new Error(`Invalid regular expression format: ${input}`);
+    }
+    const [, pattern = '', flags = ''] = matches;
+    try {
+        return new RegExp(pattern, flags);
+    } catch (error) {
+        throw new Error(`Failed to create RegExp ${error}`);
+    }
+}

package/dist/cjs/utils/text.js

@@ -21,57 +21,32 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    getDashboardDisplayName: function() {
-        return getDashboardDisplayName;
+    getResourceDisplayName: function() {
+        return getResourceDisplayName;
     },
-    getVariableDisplayName: function() {
-        return getVariableDisplayName;
-    },
-    getDatasourceDisplayName: function() {
-        return getDatasourceDisplayName;
-    },
-    getDashboardExtendedDisplayName: function() {
-        return getDashboardExtendedDisplayName;
-    },
-    getVariableExtendedDisplayName: function() {
-        return getVariableExtendedDisplayName;
-    },
-    getDatasourceExtendedDisplayName: function() {
-        return getDatasourceExtendedDisplayName;
+    getResourceExtendedDisplayName: function() {
+        return getResourceExtendedDisplayName;
     }
 });
-function getDashboardDisplayName(dashboard) {
-    var _dashboard_spec_display;
-    var _dashboard_spec_display_name;
-    return (_dashboard_spec_display_name = (_dashboard_spec_display = dashboard.spec.display) === null || _dashboard_spec_display === void 0 ? void 0 : _dashboard_spec_display.name) !== null && _dashboard_spec_display_name !== void 0 ? _dashboard_spec_display_name : dashboard.metadata.name;
-}
-function getVariableDisplayName(variable) {
-    var _variable_spec_spec_display;
-    var _variable_spec_spec_display_name;
-    return (_variable_spec_spec_display_name = (_variable_spec_spec_display = variable.spec.spec.display) === null || _variable_spec_spec_display === void 0 ? void 0 : _variable_spec_spec_display.name) !== null && _variable_spec_spec_display_name !== void 0 ? _variable_spec_spec_display_name : variable.metadata.name;
-}
-function getDatasourceDisplayName(datasource) {
-    var _datasource_spec_display;
-    return ((_datasource_spec_display = datasource.spec.display) === null || _datasource_spec_display === void 0 ? void 0 : _datasource_spec_display.name) || datasource.metadata.name;
-}
-function getDashboardExtendedDisplayName(dashboard) {
-    var _dashboard_spec_display;
-    if ((_dashboard_spec_display = dashboard.spec.display) === null || _dashboard_spec_display === void 0 ? void 0 : _dashboard_spec_display.name) {
-        return `${dashboard.spec.display.name} (Name: ${dashboard.metadata.name})`;
+function getResourceDisplayName(resource) {
+    // Variables
+    if (resource.spec.spec?.display?.name) {
+        return resource.spec.spec.display.name;
     }
-    return dashboard.metadata.name;
-}
-function getVariableExtendedDisplayName(variable) {
-    var _variable_spec_spec_display;
-    if ((_variable_spec_spec_display = variable.spec.spec.display) === null || _variable_spec_spec_display === void 0 ? void 0 : _variable_spec_spec_display.name) {
-        return `${variable.spec.spec.display.name} (Name: ${variable.metadata.name})`;
+    // Other resources with display
+    if (resource.spec.display?.name) {
+        return resource.spec.display.name;
     }
-    return variable.metadata.name;
+    return resource.metadata.name;
 }
-function getDatasourceExtendedDisplayName(datasource) {
-    var _datasource_spec_display;
-    if ((_datasource_spec_display = datasource.spec.display) === null || _datasource_spec_display === void 0 ? void 0 : _datasource_spec_display.name) {
-        return `${datasource.spec.display.name} (Name: ${datasource.metadata.name})`;
+function getResourceExtendedDisplayName(resource) {
+    // Variables
+    if (resource.spec.spec?.display?.name) {
+        return `${resource.spec.spec.display.name} (ID: ${resource.metadata.name})`;
+    }
+    // Other resources with display
+    if (resource.spec.display?.name) {
+        return `${resource.spec.display.name} (ID: ${resource.metadata.name})`;
     }
-    return datasource.metadata.name;
+    return resource.metadata.name;
 }